Sommaire

BONJOUR
Musique "Invention BWV784" J.S. BACH 1685-1750

Documentation

ASM


Notes sur le langage C

MASM32 est un ensemble d'outils de développement et de bibliothèques pour l'écriture de programmes 32 bits en assembleur.

MASM32 vous est recommandé par le Monde de Gigi

Taille : 4.78 Mo

Langue : Anglais

OS : Windows 2000 et plus

Licence : Freeware

Site de l'éditeur : http://www.le-monde-de-gigi.com/go/?url=http://www.masm32.com

MASM32 est un ensemble d'outils de développement et de bibliothèques contenant Microsoft MASM et un éditeur de liens. L'assembleur est un langage ("dit de bas niveau") de tres haute technicité qui permet d'écrire des programmes très rapide et de petite taille. Cette dernière version vous permettra d'exploiter toute la puissance de ce langage malheureusement laissé un peu à l'abandon.

Certes, il n'est pas aisé d'écrire des programmes en assembleur et seuls les plus courageux réussiront à tirer le meilleur de ce langage. Cependant, il faut bien dire que cette version permet un réel gain de temps dans la saisie du code. Avec sa syntaxe similaire aux langages de haut niveau il est presque aussi rapide de taper du code en assembleur que dans un langage comme le C.
Bref, si vous êtes amateur de performance et de prise de tête alors ce langage est fait pour vous.


Préfixes du Système international d'unités

Un article de Wikipédia, l'encyclopédie libre. Aller à : navigation, rechercher

Préfixes courants

Préfixes du Système international d'unités et noms des nombres correspondants
1000m | 10n | Préfixe français | Symbole | Depuis [note 1] | Nombre décimal | Désignation [note 2]
10008 | 1024 | yotta | Y | 1991 | 1 000 000 000 000 000 000 000 000 | Quadrillion
10007 | 1021 | zetta | Z | 1991 | 1 000 000 000 000 000 000 000 | Trilliard
10006 | 1018 | exa | E | 1975 | 1 000 000 000 000 000 000 | Trillion
10005 | 1015 | péta | P | 1975 | 1 000 000 000 000 000 | Billiard
10004 | 1012 | téra | T | 1960 | 1 000 000 000 000 | Billion
10003 | 109 | giga | G | 1960 | 1 000 000 000 | Milliard
10002 | 106 | méga | M | 1960 | 1 000 000 | Million
10001 | 103 | kilo | k | 1795 | 1 000 | Millier
10002/3 | 102 | hecto | h | 1795 | 100 | Centaine
10001/3 | 101 | déca | da | 1795 | 10 | Dizaine
10000 | 100 | (aucun) | — | — | 1 | Unité
1000−1/3 | 10−1 | déci | d | 1795 | 0,1 | Dixième
1000−2/3 | 10−2 | centi | c | 1795 | 0,01 | Centième
1000−1 | 10−3 | milli | m | 1795 | 0,001 | Millième
1000−2 | 10−6 | micro | µ | 1960 [note 3] | 0,000 001 | Millionième
1000−3 | 10−9 | nano | n | 1960 | 0,000 000 001 | Milliardième
1000−4 | 10−12 | pico | p | 1960 | 0,000 000 000 001 | Billionième
1000−5 | 10−15 | femto | f | 1964 | 0,000 000 000 000 001 | Billiardième
1000−6 | 10−18 | atto | a | 1964 | 0,000 000 000 000 000 001 | Trillionième
1000−7 | 10−21 | zepto | z | 1991 | 0,000 000 000 000 000 000 001 | Trilliardième
1000−8 | 10−24 | yocto | y | 1991 | 0,000 000 000 000 000 000 000 001 | Quadrillionième
  1. ↑ Le système métrique fut introduit en 1793 avec huit préfixes (deux n'ont pas été conservés). La date inscrite dans la colonne est celle à laquelle l'unité a été reconnue par une résolution de la CGPM .
  2. ↑ L' échelle longue utilisée ici est la référence dans les pays francophones, notamment en France, au Canada, ainsi que généralement en Europe (sauf en Grande-Bretagne). L' échelle courte est utilisée avant tout par les États-Unis d'Amérique, le Brésil, la Grande-Bretagne et les autres pays de langue anglaise (sauf le Canada).
  3. ↑ La reconnaissance en 1948 du micron par la CGPM a été abrogée en 1967. Les anglophones utilisent souvent le u minuscule au lieu du µ, par exemple dans les schémas électroniques (où on trouve uF/uH au lieu de µF/µH pour micro Farad/micro Henry), le clavier qwerty étant dépourvu de ce caractère.

Exemples

5 cm = 5×10–2 m = 5 × 0,01 m = 0,05 m

3 MW = 3×106 W = 3 × 1 000 000 W = 3 000 000 W

Étymologie

Telle qu'elle a été relevée sur le Wiktionnaire.

  • yotta- : du grec ὀκτώ, okto, « huit », et par déformation, car 1024 = 10008.
  • zetta- : de la lettre grecque ζ zeta (du grec ζῆτα, sept [1]), car 1021 = 10007. Un préfixe de la même valeur, hepta-, avait été introduit de façon non officielle avant l'adoption de zetta-. Formé sur le grec ἑπτά, hepta, « sept », il est maintenant obsolète.
  • exa- : du grec ἕξ, hex, « six » (avec omission du h initial), car 1018 = 10006.
  • péta- : du grec πέντε, pente, « cinq », et par déformation, car 1015 = 10005.
  • téra- : du grec τέρας, teras, « monstre » ;
  • giga- : du grec γίγας, gigas, « géant » ;
  • méga- : du grec μέγας, megas, « grand » ;
  • kilo- : du grec χίλιοι, chilioi, « mille » ;
  • hecto- : du grec ἑκατόν, hekaton, « cent » ;
  • déca- : du grec δέκα, deka, « dix » ;
  • déci- : du latin decimus, « dixième » ;
  • centi- : du latin centum, « cent ».
  • milli- : du latin mille, « un millier » ;
  • micro- : du grec μικρός, mikros, « petit » ;
  • nano- : du grec νάνος, nanos, « nain » ;
  • pico- : de l'italien piccolo, « petit » ;
  • femto- : du danois femten, « quinze », car 10−15 ;
  • atto- : du danois atten, « dix-huit », car 10−18 ;
  • zepto- : du latin septem, « sept », et par déformation, car 10−21 = 1000−7 ;
  • yocto- : du grec ὀκτώ, okto, « huit », et par déformation, car 10−24 = 1000−8.

Cas de l'informatique

Article connexe : préfixe binaire.

En informatique, les capacités mémoires sont en général des multiples de puissances de 2. Pour cette raison, les informaticiens de la première heure avaient l'habitude d'utiliser les préfixes kilo, méga, etc. comme des puissances de 210, soit 1 024. Toutefois la Commission électrotechnique internationale préconise, dans sa norme 60027-2, qui date de 1998, l'usage de préfixes binaires, afin d'éviter tout malentendu, même entre informaticiens[note 1]. Il est donc préférable d'utiliser ces préfixes (kibi = Ki = 1024, mébi = Mi = 10242, gibi = Gi = 10243, etc.), et de laisser aux préfixes SI leur sens recommandé (kilo = k = 1000, méga = M = 10002, giga = G = 10003, etc.).

Les fabricants et vendeurs de supports informatiques ne s'y sont pas trompés : ils préfèrent l'usage des préfixes SI, ce qui leur permet d'afficher des capacités apparemment plus importantes. Ainsi un disque dur d'une capacité de 1 téraoctet correspondrait, avec les préfixes binaires, à une capacité de 931 gibioctets, qui serait moins impressionnante pour le profane (contrairement aux mémoires RAM, les capacités des disques durs ou flash ne présentent pas d'intérêt électronique à être des puissances de 2)

Anciens préfixes

Certains préfixes ont été utilisés dans d'anciennes versions du système métrique, mais ne font plus partie du Système international officiel.

Les préfixes myria (ma et alternativement myrio, pour 10 000, mo) viennent du grec μύριοι (mýrioi) dix mille [2] .

Ces préfixes, adoptés en 1793, n'ont pas été retenus lorsque les préfixes furent fixés une première fois par la 11e CGPM de 1960.

Anciens multiples et sous-multiples [3]
10 N | Préfixe | Symbole | Multiplicateur
104 | myria | ma | Dix mille
10−4 | décimilli | dm | Dix-millième

Notes et références

Notes

  1. ↑ Confusion entre le Mo des informaticiens (1 024 × 1 024 octets) et le Mo/MByte des spécialistes réseau (1 000 × 1 000 octets/bytes).

Références

  1. ↑ Dans la numération grecque, la lettre Z valait 7, même si c'est la sixième lettre de l'alphabet. En effet la valeur 6 était représentée soit par le stigma (ϛ), soit par le digamma (ϝ).
  2. ↑ http://www.littre.org/definition/myriamètre [ archive ]
  3. ↑ Edinburgh Encyclopedia [ archive ].

Voir aussi

Articles connexes

  • Nom des grands nombres
  • Unité en aviation
  • Bureau international des poids et mesures
  • Préfixe binaire

Lien externe

  • Liste officielle du BIPM [ archive ]
[afficher] v · m Préfixes du Système international d'unités
Sous-multiples
Préfixe | yocto - | zepto - | atto - | femto - | pico - | nano - | micro - | milli - | centi - | déci -
Symbole | y | z | a | f | p | n | μ | m | c | d
Facteur | 10−24 | 10−21 | 10−18 | 10−15 | 10−12 | 10−9 | 10−6 | 10−3 | 10−2 | 10−1
Multiples
Préfixe | déca - | hecto - | kilo - | méga - | giga - | téra - | péta - | exa - | zetta - | yotta -
Symbole | da | h | k | M | G | T | P | E | Z | Y
Facteur | 101 | 102 | 103 | 106 | 109 | 1012 | 1015 | 1018 | 1021 | 1024

[afficher] v · m Système international d'unités
Unités de base | ampère · candela · kelvin · kilogramme · mètre · mole · seconde
Unités dérivées | becquerel · coulomb · degré Celsius · farad · gray · henry · hertz · joule · katal · lumen · lux · newton · ohm · pascal · radian · siemens · sievert · stéradian · tesla · volt · watt · weber
Préfixes | yocto · zepto · atto · femto · pico · nano · micro · milli · centi · déci · déca · hecto · kilo · méga · giga · téra · péta · exa · zetta · yotta
Nouvelles définitions du Système international d'unités · Ordre de grandeur
[afficher] v · m Principaux systèmes d'unités
Système international | Unités de base · Unités dérivées · Préfixes du Système international d'unités · Nouvelles définitions du Système international d'unités
Système CGS centimètre · gramme · seconde
Système astronomique unité astronomique · masse solaire · jour
Système d'unités naturelles Système d'unités géométriques · Unités de Planck
 · Analyse dimensionnelle · Grandeur sans dimension · Effet d'échelle
Systèmes de mesure anciens
Systèmes désuets | Unités de mesure chinoises · Unités de mesure dans l'Égypte antique · Unités de mesure romaines · Unités françaises de mesure anciennes · Unités espagnoles de mesure anciennes · Unités maltaises de mesure anciennes
Systèmes traditionnels | Unités de mesure anglo-saxonnes · Unités de mesure américaines · Unités de mesure thaïlandaises
Systèmes spécifiques | Système des apothicaires
Grandeur physique · Constante physique · Ordre de grandeur · Unité de mesure · Unité fondamentale · Unité réduite · Conversion des unités · Métrologie
[afficher] v · m Ordres de grandeur
Concentration · Densité surfacique · Données · Énergie · Fréquence · Longueur · Masse · Masse volumique · Monétaire · Nombres · Pression · Puissance · Superficie · Température · Temps · Vitesse · Volume
Préfixes du Système international d'unités · Système d'unités naturelles


Langage de programmation - Vue par chronologie

Vu dans ... https://www.gladir.com/CODER/referencechronology.htm

Chronologie par date de création

Date | Langage | Auteur
1950 | Assembleur | Maurice V. Wilkes
1951 | Assembleur UNIVAC I | ECC
1954 | Fortran (FORmula TRANslator) | John Backus, IBM
1959 | Jovial | Jules I. Schwartz
1960 | Cobol | Le comité Codasyl
1960 | Algol 60 |
1962 | Snobol | Griswold
1964 | PL/1 | IBM
1964 | Basic | Kemeny et Kurtz
1967 | BCPL (Basic Combined Programming Language) | Martin Richards
1968 | Logo | Seymour Papert
1970 | B | Ken Thompson
1970 | Assembleur 370 | IBM
1971 | Pascal | Niklaus Wirth, Jensen
1972 | C | Dennis Ritchie
1972 | Smalltalk | Digitalk
1979 | Modula-2 | Niklaus Wirth
1979 | AWK | Alfred V. Aho, Peter J. Weinberger et Brian W. Kernighan
1979 | REXX | Mike Cowlishaw
1983 | Ada | Département de la défense américaine
1983 | C++ | Bjarne Stroustrup
1983 | BASICA/GWBASIC | Microsoft
1983 | Turbo Pascal | Anders Hejlsberg
1985 | Quick Basic | Microsoft
1986 | Quick C | Microsoft
1987 | Perl | Larry Wall
1987 | Turbo Basic | Borland
1987 | Turbo C | Borland
1988 | TCL (Tool Command Language) | John Ousterhout
1989 | Oberon | Niklaus Wirth
1989 | Power Basic | Bob Zale
1989 | Quick Pascal | Microsoft
1989 | Turbo Pascal avec POO (Programmation Orienté Objet) | Borland
1990 | HTML | Tim Berners-Lee
1991 | Python | Van Rossum
1991 | Visual Basic (VB) | Alan Cooper, Microsoft
1992 | Borland Pascal 7 | Borland
1993 | Ruby | Yukihiro Matsumoto aka Matz
1995 | Delphi | Borland
1995 | Java | Sun Microsystems ( Oracle)
1995 | JavaScript | Netscape
1995 | PHP | Rasmus Lerdorf
1996 | CSS (Feuille de style) | W3C
2000 | C# (C Sharp) | Microsoft
2000 | Virtual Pascal | Morten Mertner
2001 | Kylix | Borland

Chronologie par popularité

Certains langages existent depuis longtemps et ont été populaires des dizaines d'années plus tard, d'autres sont restés assez constants, il est très difficile d'être juste et équitable pour tous. D'autant plus, que certains langages ont continué d'exister, mais se sont fait tasser par d'autres langages ou mélange de technologie et de langage. Également, certains langages ont été très bons mais ne sont jamais devenu populaire. Voici tout de même un tableau des tendances de langages de programmation par popularité en tranche de 5 ans :


What is HEXADECIMAL and Where, How and Why is It used on Computers?

Sponsoring website: Emergency Boot CD

0123456789ABCDEF    0123456789ABCDEF    0123456789ABCDEF

What Is "Hexadecimal" ?

and

Where, How, and Why is it used on Computers?

Copyright © 1996, 1999, 2000, 2002, 2004, 2011 by Daniel B. Sedory

All new Revision in 1999. Now contains an explanation of the use of Hexadecimal
for R - G - B colors as used in HTML for web pages ( Hexadecimal Colors in HTML )
(And a link to a combined free HEX <---> DECIMAL converter and HTML color coder!)
Updated with links to Wikipedia, 2011.

    Introduction

    "Hexa... What?" Well, that's hexa- (six) plus decimal (ten), or sixteen.
    It stands for the Base 16 Number System. Programmers often refer to it as simply, Hex (which by itself should mean only six, such as the number of sides that a "Hex wrench" has, but it almost always means Hexadecimal if the subject is computer software rather than hardware).

    You may already know that Binary (or Base 2) is what computers actually use to carry out calculations. Octal is Base 8, and Decimal, of course, is Base 10. And just as we have ten digits, 0 through 9, in the Decimal system, there are sixteen digits we could use for Hexadecimal (0-9 and six more).

    The Basics of Hex

    The following tables show how the first six letters of the Latin alphabet (which are the same for most European languages; including English) are used as symbols in Hex so we can have a total of 16 Hexadecimal digits. Though it's now standard practice to use the capitals A through F (or lower-case forms if their meaning is unambiguous) to symbolize the Tenth through Sixteenth digits of the Hexadecimal Number System, remember, this is only a convention; any other set of 6 symbols (such as letters from Arabic, Korean or Japanese) could function in the same way; as well as any other symbols could for the Decimals 0-9.

 Hexadecimal          Decimal    |  Hexadecimal     Decimal
-------------       -----------  |  -----------     -------
 0 through 9        0 through 9  |
                                 |  1D  (1 x 16) + 13 = 29
      A   ( 9 + 1 = )    10      |  1E     "     + 14 = 30
      B   ( 9 + 2 = )    11      |  1F     "     + 15 = 31
      C   ( 9 + 3 = )    12      |  20  (2 x 16) +  0 = 32
      D   ( 9 + 4 = )    13      |  21     "     +  1 = 33
      E   ( 9 + 5 = )    14      |  22     "     +  2 = 34
      F   ( 9 + 6 = )    15      |  23     "     +  3 = 35
     10   (1 x 16) + 0 = 16      |  24     "     +  4 = 36
     11   (1 x 16) + 1 = 17      |  25     "     +  5 = 37
     12      "    +  2 = 18      |  26     "     +  6 = 38
     13      "    +  3 = 19      |  27     "     +  7 = 39
     14      "    +  4 = 20      |  28     "     +  8 = 40
     15      "    +  5 = 21      |  29     "     +  9 = 41
     16      "    +  6 = 22      |  2A     "     + 10 = 42
     17      "    +  7 = 23      |  2B     "     + 11 = 43
     18      "    +  8 = 24      |  2C     "     + 12 = 44
     19      "    +  9 = 25      |  2D     "     + 13 = 45
     1A      "    + 10 = 26      |  2E     "     + 14 = 46
     1B      "    + 11 = 27      |  2F     "     + 15 = 47
     1C      "    + 12 = 28      |  30  (3 x 16) +  0 = 48

    Just as the location of the digits in a Decimal number represent the amount of ones, tens, hundreds, thousands, etc. in that number; which are the powers of 10. In a similar way, the digits in a Hex number stand for the ones, sixteens (16 to the power of 1), how many 256s (16 to the power of 2), the amount of 4096s (16 to the power of 3), etc. in its numbers.

    The following table includes some important(*) Hex numbers in the PC industry; such as 200h (a small h, or capital H, at the end of a number means it's a Hexadecimal number; to prevent it from being mistaken as a Decimal number).

 Hexadecimal          Decimal   Hexadecimal          Decimal
 -----------          -------   -----------          -------
     30    (3x16) + 0 =  48   |     100    (1x256) =    256
     40    (4x16) + 0 =  64   |(*)  200    (2x256) =    512
     50    (5x16) + 0 =  80   |     400    (4x256) =   1024
     64    (6x16) + 4 = 100   |     500    (5x256) =   1280
(*)  7F    (7x16) +15 = 127   |     800    (8x256) =   2048
     80    (8x16) + 0 = 128   |     A00   (10x256) =   2560
     90    (9x16) + 0 = 144   |     FFF                4095
     9F    (9x16) +15 = 159   |    1000   (1x4096) =   4096
     A0   (10x16) + 0 = 160   |    4000   (4x4096) = 16,384
     B0   (11x16) + 0 = 176   |    5000   (5x4096) = 20,480
     F0   (15x16) + 0 = 240   |    8000   (8x4096) = 32,768
(*)  FF   (15x16) +15 = 255   |(*) FFFF              65,535

    FFFFh = (15x4096) + (15x256) + (15x16) + 15 = 65,535 ; which is the largest value that can be represented within sixteen Binary digits. 200h is the Hex equivalent for 512, as in: bytes per sector on both floppy and hard disks. Multiples of these sectors are sometimes called clusters. The format for a Windows™ 2000 or XP OS partition is usually NTFS; which often has 4 KiB clusters (or 8 "sectors per cluster"). Files are always stored on your computer (under the FAT or NTFS file systems) by dividing them up into clusters. The last cluster is almost never completely filled in by a file (it's often called slack space). Just before FAT32 was invented, many people had hard drives that used 32 KiB clusters; with lots of wasted space on them. The space you save by using Windows™ 2000/XP with NTFS rather than FAT32 can be huge since the size of new drives has already reached triple digits of Gigabytes!

So, what does a Base 16 number system have to do with a machine that's based ( [image] pun intended) on zeros and ones?

    Do any of those numbers above look familiar to you, specifically the number 1024 and its multiples? It's more than just a coincidence that this is equal to the term we call a Binary Kilobyte (1024 bytes, or 2 to the power of 10 or 1 KiB). The 2 Kib, 4 Kib and 16 Kib multiples of this Binary number should now be evident in the Table above. 10,000 Hex (FFFFh + 1) is equivalent to 64 Binary KB (65,536 bytes, or 2 to the power of 16) which is the largest size a true .COM program* can have.

    After laying some groundwork from the past, we'll return to these observations and answer that important question in the box above! Hopefully you'll enjoy the following commentary on highlights from the history of computing.

_____________________
*Perhaps you've heard of the file COMMAND.COM (it's the kernel for the MS-DOS 7.1 Operating System on a Windows™ 98 Boot Disk). Well it's really an .EXE program! Microsoft® simply felt it had to retain the same name for this file, most likely for compatibility reasons; it hasn't been an actual .COM file since Windows™ 95 was released. A true .COM program can never be more than 64 KiB in size, and does not begin with the letters "MZ" (which you'll find at the beginning of this COMMAND.COM file and all other .EXE files).

A Quick Look at the Amazing History of Computers

Over half a century ago, hot, room-sized machines built with vacuum tubes and relays were already using the same concepts we still use today to carry out instructions on numbers stored as "bits" (Binary digits) in structures known as registers. Today, even our hand-held programmable calculators could blow away those old computers in speed if not in results (number of digits). And the registers have shrunk from the size of handfuls of light bulbs to a space so tiny you need an electron microscope to see it; yet they still continue to add, subtract and compare bits by the same logical methods already known long before those now archaic machines could have been built.

Programs were often stored and fed into those first computers from patterns of holes punched into a roll of paper tape (Punched Tape). This idea came from an earlier device called the teletype (or teletypewriter or teleprinter), which used a seven-bit code we now call ASCII to send alphanumeric data over wires. Essentially this same bit code or expansions upon it, such as Unicode, are still used to store data on a PC. Designed for communications, the original code included control characters to signal the start of, success, failure, and end of transmissions. The ASCII code 7, was used to ring a real bell at a distant station, thus it is often abbreviated as "bell" in an ASCII chart. Programs now use it to beep a computer's speaker!

Some of the 33 control codes used decades ago, such as ASCII 8 (a Backspace), 10 [0Ah] (a Line Feed), and 13 [0Dh] (a Carriage-Return) are still fairly close to their original meanings, while others were so "device dependent" that modern day equivalents no longer exist.

Seven bits gives us a total of 128 different codes in the standard ASCII character set. That's 64 + 32 + 16 + 8 + 4 + 2 + 1 or 127, plus the zero. At a much later date, companies such as IBM® and Apple® introduced their own Extended ASCII character sets; which were eventually followed by Unicode.

The revolution in electronics which made home computing possible came about when integrated circuit companies, such as Motorola®, Intel®, Rockwell® and Zilog®, began mass producing 8-bit microprocessors in the early Seventies. The Motorola® MC6800 series made the loveable little Apple™ computers an instant success, and the Zilog® Z-80 ™ made the Tandy® (Radio Shack) TRS-80 ™ a very common product. Finally, in 1979, Intel's 4.77 MHz 8088 chip (a 16-bit CPU with only an 8-bit bus) found a home inside the original IBM® Personal Computer™ [Note: The Intel 8086, with a full 16-bit bus, had already been produced in 1978, but IBM considered it too expensive to use for their first PC project.] In 1984, IBM introduced it's AT (Advanced Technology) series based on Intel's 80286 CPU. That computer (made by the 'business company' IBM), may have been what convinced many managers and CEOs that microcomputers would soon become the future of computing in the business world. (Well, that and the fact that further technological advances allowed PCs to be "Networked" together through server machines! Once they became widely used in large businesses, the PCs tended to cause data which had only been stored in the tape libraries of main-frame computers to become distributed among "workstations" as they're now called; rather than just being "dumb" terminals that had to access what some still thought of as a "real computer" in order to do something useful.)

A Few Details about the IBM PC and Microsoft

Instead of making its own Disk Operating System, IBM® paid a little software company to put together a DOS for their new IBM Personal Computers. But, IBM did not pay for exclusive rights to any future uses of this DOS. And when that little company (called Microsoft®) made some changes and started selling MS-DOS™ to anyone, it wasn't long until a flood of "AT clones" and "IBM - compatibles" spread across the globe! Microsoft and Intel® made a fortune selling the essential software and hardware that made up a PC, but IBM simply acted like its usual "big blue" self over the losses in home and small business sales. I'm sure that IBM now wishes they had done things differently, but perhaps that's what they deserved for making a calculated decision to promote Microsoft's DOS instead of an 8086 version of CP/M by Gary Kildall (which later became Digital Research DOS). And in spite of what you may read elsewhere, Gary never 'lost out' to Bill Gates due to any personal differences or missed meetings! It was simply a business decision by IBM; which appears to have been done on purpose since IBM's DOS could only be used on their machines, whereas Gary's OS was almost machine independent. It's a little known fact (these days) that IBM actually licensed both DOS and CP/M-86 for their PC, but you had to special order CP/M-86 rather than having it come at a much lower price with most PCs as IBM's DOS did; that was clearly a business decision on the part of IBM!

Bits, Bytes, Characters and Words

    Data in these new microcomputers was contained in 8-bit units called "bytes" (a combination of the word bit and to bite; a 4-bit unit is often called a "nibble" [image] ). IBM® later added an extended-ASCII character set for their PCs, which doubled the size from 128 to 256 codes. Inside the Processor itself (the CPU), there were also registers of 16-bit lengths. The machine code which ran the CPU could have instructions of this size too, or even larger, arriving at the CPU in a number of successive bytes. It was around this time, that the term "word" took on its usual meaning of two eight-bit bytes. So, how did they manipulate such large binary numbers without making too many mistakes?

    Why Octal and Hexadecimal are used On Computers

    Long before this, programmers regularly used a convenient method to handle large binary numbers in either 3-bit or 4-bit groupings. Most people find it quite easy to see what decimal numbers are represented by only three bits; for example, 101 is 5, 011 is 3, etc. If we use the 3-bits at a time method to convert the binary number 111000101000 into groups of 3-bit decimal digits, we obtain: 7 0 5 0. "If you needed to turn this into an Octal (Base 8) number, what more would you need to do?" Nothing! The digits 7050 are the Octal equivalent of this Binary number; it's almost too simple. But to convert either of them into Decimal is a lot more difficult for most of us; yet it's quite often unnecessary for a programmer to do so.

    Not long after computers needed to be programmed, the actual machine code for the computer instructions was replaced by mnemonics (first m is silent when pronouncing this word; it essentially means abbreviations). Three or four letters (at first), were used in what was called the Assembly Language for a particular CPU; thus, today we have the x86 Assembly code (in various forms) for Intel-based computers. It was also possible to use more than one base numeration for writing data in these Assembly languages, so programmers made sure their Assemblers [the programs which convert Assembly language into a particular machine code] could understand Octal as well as Binary numbers.

    Well, what about Hexadecimal? The same Binary number above, grouped into four bits at a time, will give us the Hex numerals, E28. Now we're finally getting to the bottom of that important question above; and the main reason I wanted to write this essay.

    The maximum number a four-bit Binary can represent is 15. Exactly the same as a single Hex digit. And if you sum up the next four higher bits in a Binary number having eight bits, for example, the ones in 11110000, you'll get 16+32+64+128 = 240, or simply 15 times 16. And the next four bits beyond that will give you 15 times 256, or 3840.

    Let's compare the differences between grouping the Binary digits in sets of fours (for Hexadecimal) and threes (for Octal) in a more graphic manner :

Binary:  | 2048 1024 512 256 | 128 64 32 16 | 8 4 2 1 | = 1111 1111 1111
  HEX :  |       256's       |     16's     |   1's   | =   F    F    F
-------------------------------------------------------------------------
Computing      (15 x 256)    +  (15 x 16 )  +   15
 Decimal          3840       +     240      +   15      =    4 0 9 5
equivalent
=========================================================================
Binary: |2048 1024 512 | 256 128 64 | 32 16 8 | 4 2 1 | = 111 111 111 111
 OCTAL: |    512's     |     64's   |   8's   |   1's | =  7   7   7   7
-------------------------------------------------------------------------
Computing ( 7 x 512 ) +  ( 7 x 64 ) + (7 x 8) +   7
 Decimal     3584     +     448     +    56   +   7     =    4 0 9 5
eqivalent
=========================================================================
 F F F h  =  7 7 7 7  Octal  =  4 0 9 5 (Decimal).

    This shows that it's almost as easy to extract a Hexadecimal number from a Binary as it was to obtain its Octal eqivalent. We simply group the Binary bits by four digits instead of three.

    Conclusion

    There are two important aspects to the beauty of using Hexadecimal with computers: First, it can represent 16-bit words in only four Hex digits, or 8-bit bytes in just two; thus, by using a numeration with more symbols, it is both easier to work with (saving paper and screen space) and makes it possible to understand some of the vast streams of data inside a computer merely by looking at the Hex output. This is why programs such as DEBUG, use only Hexadecimal to display the actual Binary bytes of a Memory Dump rather than a huge number of ones and zeros!

    The second aspect is closely related: Whenever it is necessary to convert the Hex representation back into the actual Binary bits, the process is simple enough to be done in your own mind. For example, FAD7 hex is 1111101011010111 (F=1111, A=1010, D=1101, 7=0111) in Binary. The reason one might wish to do this is in order to work with "logical" (AND, OR or XOR) or "bit-oriented" instructions (Bit tests, etc.) which may make it easier (at times) for a programmer to comprehend.

    For example, if you wanted to logically AND the hex number FAD7 with D37E, you might have a difficult time without first changing these numbers into Binary. If you jot them out in Binary on scratch paper, the task will be much easier:

   FAD7(hex) =  1 1 1 1  1 0 1 0  1 1 0 1  0 1 1 1
   D37E(hex) =  1 1 0 1  0 0 1 1  0 1 1 1  1 1 1 0
               ------------------------------------
 ANDing gives:  1 1 0 1  0 0 1 0  0 1 0 1  0 1 1 0
   the Answer:     D       2        5       6
     (in hex)

    FINAL THOUGHTS

    One final bit of advice: Remember that memory, stored programs, or codes always begin counting their locations or offsets with a ZERO (0). So, to arrive at a total you must add a one (1) to whatever number you see in the tables above: Thus, the amount of total memory locations in FF hex or the total length in bytes of a program that ends at offset FFh is 256 (inclusive), not just 255. In this case, an old phrase you may have heard, "nothing counts," is quite literally true as a zero stands for the first (1st) location you start counting from.

    However, any given 8-bit byte of memory, can never hold or count up to anything larger than FF hex, or 255, since a zero in a memory register represents the idea of nothing being in there (a true nil or null). In this case, the zero in a data register does not really count, because it is being used as a symbol to convey the idea that there isn't anything in there yet; it's only a void or emptiness!

    APPENDIX on
    Hexadecimal Colors in HTML
    (Here's a new file on: The 16 Windows Colors)

    Along with the advances in Microcomputers, "the Internet" has experienced many changes as well. A code still used by "Web browsers" today had been invented to transfer information from servers to terminals in a way that made the Internet a much more effective tool for research. That code is called "Hyper-Text Markup Language" (or HTML) and it soon included a method which could theoretically reproduce background and text with a total of 16 million, 777 thousand, 216 different colors.

    The hardware available today has already advanced way beyond that limit. The main reason was a push to display pictures "in living color;" now a common reality. And one of the first things a new computer user should always do is make sure their display can be set to what's called "24-bit" or "True Color" (for those 16-million plus possible colors). As a matter of fact, almost every video card today has the capacity to reproduce what's called "32-bit" color. But all those extra bits are not used for increasing the number of colors! Why? Well, since the human eye is only capable of distinguishing something like 7 million or so different colors, that would be a real waste of technology! But you'll have to look for another page about video cards if you want to know more; our task here is to simply explain the use color with HTML code.

    Soon there were two very typical lines of HTML code being used to create background colors:

      <body bgcolor="#FFFFFF">  for an all white background
and
  <body bgcolor="#CCCCCC">  for a light-gray background
    As a matter of fact, some browsers display an all-white background as their default (when no color is given) whereas others use a light-gray color to display such backgrounds. And "#000000" is used to make pages with an all-black background. The three PRIMARY colors (RED, GREEN and BLUE) were each assigned TWO HEXADECIMAL DIGITS within this six-digit hexadecimal number : Each of the component colors (R-G-B) can, therefore, contribute a maximum of 256 different shades (zero through 255) to the final appearance of the background or text color. Here's a list which shows how easy it is to make six basic colors. The lines shown here contain the HTML "tag" pairs on either side of the TEXT color they create. (For those who may have a problem seeing one or more of the colors, the name also appears at the end of each line in parentheses):
                                              HTML TAG Name
 <font color="#FF0000">  RED   </font>  (RED)
 <font color="#00FF00"> GREEN  </font>  (GREEN)    LIME
 <font color="#0000FF">  BLUE  </font>  (BLUE)
 <font color="#FFFF00"> YELLOW </font>  (YELLOW)
 <font color="#FF00FF"> VIOLET </font>  (VIOLET)  FUCHSIA
 <font color="#00FFFF">  CYAN  </font>  (CYAN)     AQUA

    You can now see that YELLOW really is a combination of Red and Green. When you combine Red and Blue it makes Violet (FUCHSIA), and displaying Green and Blue together causes the eye to see CYAN (AQUA). Other colors are formed by limiting the intensity of one or more of the three Primary Colors. E.g., cutting the values for the Green and Blue of Cyan in half gives you the default color for the MS-Windows™ 98 Desktop called TEAL (color = "#007F7F" ).
    [Note: Although you'll often see the word "Green" as the name for the Primary Color represented by "#00FF00" above, when it came time to assign the names of colors to HTML "tags" for Netscape's browser, they ended up calling this color "Lime" and assigned the name Green to half the full value: either "#007F00" (or "#008000").]

    For some reason when the first web browsers (including Netscape) were made, even though video cards used what was called VGA and could reproduce 256 different colors, some of those colors were not compatible with the web browsers! Later browsers, such as Microsoft's series, could handle all 256 colors. Rather than have their webpages possibly look bad for some people, many commercial HTML authors still use a subset of the 256 colors which are called "Browser Safe" or just "Safety" colors.

    There are FOUR different webpages here which contain SAMPLES of all 216 colors in this "safety palette." Each consists of a large table that shows either the Hexadecimal Code or the R-G-B Notation for each color on a page with either a Black or a White background:

    Hexadecimal - White Background
    Hexadecimal - Black Background
    R-G-B Notation - White Background
    and R-G-B Notation - Black Background

    [ Here's the link to that FREE program I promised you. It does HEX and DECIMAL conversions, shows Hexadecimal and R-G-B Color Notations, allows you to pick a 24-bit "True Color" from a visual display and also performs logical operations and conversions on a maximum of 32-bit binaries: B I T S (Version 1.7) ]

Copyright ©1996,1997,1999,2000,2002,2003,2004 by  Daniel B. Sedory
 < Online reply form here >

Revised on November 7th, 2003. Updated: 25 OCT 2004
Last Update: May 31, 2011.

Back to " The Starman's Realm " Index Page


Accueil

Accueil CHM


Table de Karnaugh — Wikipédia

Table de Karnaugh

Un article de Wikipédia, l'encyclopédie libre.

Une table de Karnaugh (prononcé [k a ʁ . n o]) est une méthode graphique et simple pour trouver ou simplifier une fonction logique à partir de sa table de vérité. Elle utilise le code de Gray (aussi appelé binaire réfléchi), qui a comme propriété principale de ne faire varier qu'un seul bit entre deux mots successifs (la distance de Hamming de deux mots successifs du code de Gray est égale à 1).

Cette méthode a été développée par Maurice Karnaugh en 1953, en perfectionnant un diagramme similaire introduit en 1952 par Edward Veitch (en).

Sommaire

  • 1 Principe

  • 2 Méthode de recherche de l'équation

    • 2.1 La somme

    • 2.2 Le produit

    • 2.3 Utilisation

      • 2.3.1 Extension aux fonctions partiellement définies

  • 3 Notes et références

  • 4 Voir aussi

    • 4.1 Articles connexes

  • 5 Les logiciels

Principe

Un tableau de Karnaugh peut être vu comme une table de vérité particulière, à deux dimensions, destinées à faire apparaître visuellement les simplifications possibles.

Supposons 2n ou 2n+1 variables : on assignera par exemple n ou n+1 variables au repérage des lignes, les n autres variables au repérage des colonnes. Chaque case élémentaire correspond alors à une seule ligne et à une seule colonne, donc à une seule combinaison des variables.

Examinons le cas d'une fonction S des quatre variables A, B, C, D, les variables A et B étant assignées aux lignes, C et D aux colonnes de la table ci-dessous.

Table de Karnaugh

S | CD | 00 | 01 | 11 | 10
AB |  |  |  |  |
00 |  | 0 | 1 | 1 | 0
01 |  | 0 | 1 | 1 | 1
11 |  | 0 | 1 | 1 | 1
10 |  | 0 | 1 | 1 | 0

Cette table est proche du diagramme de Veitch antérieur. Pour rendre plus évidentes les simplifications cherchées, Karnaugh propose, pour la succession des valeurs données à C et D, ainsi qu'à A et B, d'employer un code de Gray, de sorte que les valeurs de deux repères consécutifs ne diffèrent que par la modification d'une seule variable, et fasse apparaître des symétries utiles. Ainsi :

  • La colonne 1 correspond aux valeurs de S pour C=0 et D=0, ou C'D' = 1

  • La colonne 2 correspond aux valeurs de S pour C=0 et D=1, ou C'D = 1

  • La colonne 3 correspond aux valeurs de S pour C=1 et D=1, ou CD = 1

  • La colonne 4 correspond aux valeurs de S pour C=1 et D=0, ou CD' = 1

  • La ligne 1 correspond aux valeurs de S pour A=0 et B=0, ou A'B' = 1

  • La ligne 2 correspond aux valeurs de S pour A=0 et B=1, ou A'B = 1

  • La ligne 3 correspond aux valeurs de S pour A=1 et B=1, ou AB = 1

  • La ligne 4 correspond aux valeurs de S pour A=1 et B=0, ou AB' =1.

Alors, on assigne à la case de la ligne 4, colonne 2 la valeur de S quand A=1, B=0, C=0 et D=1. Cette valeur peut être trouvée dans la table de vérité ou par une équation à simplifier.

Les valeurs du tableau de Karnaugh considéré correspondent aux valeurs de la table de vérité suivante :

Table de vérité

A | B | C | D | S
0 | 0 | 0 | 0 | 0
0 | 0 | 0 | 1 | 1
0 | 0 | 1 | 0 | 0
0 | 0 | 1 | 1 | 1
0 | 1 | 0 | 0 | 0
0 | 1 | 0 | 1 | 1
0 | 1 | 1 | 0 | 1
0 | 1 | 1 | 1 | 1
1 | 0 | 0 | 0 | 0
1 | 0 | 0 | 1 | 1
1 | 0 | 1 | 0 | 0
1 | 0 | 1 | 1 | 1
1 | 1 | 0 | 0 | 0
1 | 1 | 0 | 1 | 1
1 | 1 | 1 | 0 | 1
1 | 1 | 1 | 1 | 1

Méthode de recherche de l'équation

Pour trouver l'équation de S, c'est simple. Il y a deux méthodes :

  • former une somme ;

  • former un produit.

La somme

Pour trouver une somme, il faut regrouper les valeurs de S égales à 1. Le nombre de 1 dans chaque groupe doit être égal à une puissance de 2. Les groupes formés doivent être les moins nombreux possibles, mais ils doivent englober tous les 1. Un 1 peut être inclus dans plus d'un groupe, par contre aucun 0 ne doit être inclus. Les groupes sont composés d'une ou plusieurs colonnes et d'une ou plusieurs lignes. Si possible, assemblez-les par valeurs d'entrées communes. Par exemple, la colonne 2 et la colonne 3 ont pour valeur commune D=1. La ligne 1 et la ligne 4 ont la valeur B=0 en commun..

Pour les tables à 4 variables, de préférence procéder dans l'ordre suivant :

  • Le rectangle 16 cases puis,

  • les rectangles 8 cases puis,

Utilisation de la table de Karnaugh

  • les rectangles 4 cases puis,

  • les rectangles 2 cases et,

  • enfin les cases uniques.

Dans l'exemple pris ci-dessus : on peut former un rectangle de 8 cases, puis un carré de 4 (le rectangle des colonnes 2 et 3 et le carré au croisement des lignes 2-3 et des colonnes 3-4). Le rectangle correspond à l'équation « D » car dans ces deux colonnes et dans ces deux colonnes seulement, D est toujours égal à 1. Le carré correspond à l'équation « B·C » car dans ces cases et dans ces cases seulement B=1 et C=1. S est représenté par l'union des 2 figures, et on obtient pour équation de S : « S = D + B·C ».

Cette méthode, une fois assimilée, permet de trouver une équation au premier coup d'œil, et propose une alternative simple à la simplification d'équation, qui peut rapidement devenir fastidieuse.

Le produit

Cette méthode ne regroupe pas les « 1 » mais les « 0 », pour trouver non pas une somme de produits mais un produit de sommes.

En regroupant les 0, on trouve S' sous forme d'une somme, et par complémentation, on obtient S sous forme de produit.

Ici, en regroupant les 0 de S (ou 1 de S') on obtient S' = C'D'+ B'D', le premier terme regroupant la 1re colonne, et le second les 4 coins. Donc, par la règle de De Morgan, S = (C+D)·(B+D) : S est maintenant vu comme l'intersection de C+D, qui représente les colonnes 1 à 3, et de B+D, qui représente le carré total hormis les 4 coins [1].

Utilisation

Les tables/tableaux de Karnaugh sont surtout utilisé(e)s en électronique. En effet, la simplification de l'expression algébrique booléenne permet d'économiser des opérateurs logiques (portes logiques) et donc des circuits. Elle engendre aussi une économie de temps de conception et de fonds, tout en augmentant la fiabilité de l'ensemble.

En programmation, l'utilisation des tables de Karnaugh permet de réduire les séquences de conditions de test complexes en les regroupant en des conditions non intuitives au premier abord, mais qui réduisent la complexité effective du code (volume du source), ainsi que son temps d'exécution en réduisant le nombre des évaluations nécessaires.

Extension aux fonctions partiellement définies

Parfois la fonction à réaliser n'est que partiellement définie. Par exemple, si une fonction dépend de 4 variables représentant le codage binaire d'un chiffre décimal, seuls 10 cas sont définis sur 16. Alors, les cases non définies reçoivent une marque spéciale différente de 0 et de 1 (par exemple x ou Φ), et deviennent annexables aux points employés sans l'être aux points à réaliser. On peut donc trouver des solutions plus simples, moins coûteuses, car les cas indéfinis font partie des possibilités sans faire partie des points nécessaires. Si, dans notre exemple, 10 cas sont définis sur 16, alors 2^6 = 64 fonctions complètement déterminées sont compatibles avec notre fonction, et toute réalisation d'une fonction compatible pourra être employée comme réalisation de la fonction incomplète visée.

Notes et références

  1. ↑ Les 4 coins forment un carré si on pense que les bords parallèles se touchent, comme si le diagramme était dessiné sur une sphère

Voir aussi

Sur les autres projets Wikimedia :

  • Table de Karnaugh, sur Wikimedia Commons

  • Table de Karnaugh, sur Wikiversity

  • Électronique numérique : logique, sur Wikibooks

Articles connexes

  • système binaire

  • électronique numérique

  • algèbre de Boole

Les logiciels

  • Gorgeous Karnaugh [archive] - un des meilleurs dans le logiciel[réf. nécessaire] de minimisation de K-cartes mondial

  • Bmin [archive], Qt ouvrez l'application Source - les cartes de Karnaugh et la 3e visualisation de n-cube Booléenne, Quine-McCluskey et la minimisation d'Express, "PoS" et la représentation "SoP" de fonctions et plus.

  • Karma [archive], un ensemble d'outils de synthèse logiques en incluant des cartes de Karnaugh, une minimisation de Quine-McCluskey, un module enseignant et plus. Laboratoires de Synthèse de Circuit logiques.

  • Kmap minimizer [archive] Application Flash en ligne.

  • GKMap [archive], application de logiciel gratuit à SourceForge.net.

  • Karnaugh Map Minimizer [archive], libre (mais souvent incorrect[réf. nécessaire], essayez avec cette équation : 0,1,5,8,10,13) l'application de logiciel à SourceForge.net.


La méthode de Quine est un algorithme systématique permettant de simplifier une fonction logique quelconque de plusieurs variables.

Sommaire

  • 1 Principe de la méthode
  • 2 Illustration sur un exemple
    • 2.1 Table de vérité
    • 2.2 Étape n°1 : Identification des termes générateurs
    • 2.3 Étape n°2 : Suppression des redondances
    • 2.4 Résultat final

Principe de la méthode

L'algorithme se déroule en deux étapes. Pour faciliter la mise en œuvre de la méthode, la fonction logique doit être exprimée soit sous forme tabulaire (table de vérité, tableau de Karnaugh), soit sous la forme suivante :

Où [image] sont k valeurs (exprimées en binaire ou plus souvent en décimal) correspondant aux k cas où [image] , avec le nombre [image] , vaut 1 et [image] sont p valeurs correspondant aux p cas où [image] , avec le nombre [image] est indéterminé. Par exemple, l'expression d'une porte NAND sous cette forme serait : .

La première étape de l'algorithme correspond à la recherche de l'ensemble des termes générateurs. Un terme est générateur s'il ne peut être combiné avec aucun autre terme pour donner un terme plus simple.

Par exemple, dans le cas de la porte NAND, la fonction vaut 1 lorsque (ab) vaut 00 , 01 ou 10 . Le terme 00 n'est pas un terme générateur car combiné avec 01 , il donne naissance à un terme plus simple 0x . En revanche, 0x ne peut être combiné avec un autre terme, c'est donc un terme générateur. De la même manière x0 est un autre terme générateur.

Pour trouver les termes générateurs, on utilise les valeurs [image] et [image] car, comme dans un tableau de Karnaugh, les termes indéterminés peuvent conduire à des simplifications.

La deuxième étape de l'algorithme correspond à l'élimination, parmi les termes générateurs, des termes redondants. Pour cela, on identifie les termes générateurs à partir desquels chaque [image] peut-être écrit et on élimine ceux qui sont en trop.

Par exemple, dans le cas de la porte NAND, le terme 00 et 01 peuvent être écrit avec le terme générateur 0x mais celui-ci n'est pas utilisable pour écrire 10 . L'utilisation du second générateur x0 est indispensable. Il n'y a pas de terme redondant.

Pour cette étape de simplification, on ne cherche à coder que les valeurs [image] . Les valeurs indéterminés nous sont ici inutiles.

Illustration sur un exemple

Table de vérité

Considérons la table de vérité suivante

A | B | C | D | S
0 | 0 | 0 | 0 | 1
0 | 0 | 0 | 1 | 0
0 | 0 | 1 | 0 | 1
0 | 0 | 1 | 1 | 0
0 | 1 | 0 | 0 | 0
0 | 1 | 0 | 1 | 0
0 | 1 | 1 | 0 | 1
0 | 1 | 1 | 1 | 0
1 | 0 | 0 | 0 | 1
1 | 0 | 0 | 1 | 0
1 | 0 | 1 | 0 | x
1 | 0 | 1 | 1 | x
1 | 1 | 0 | 0 | x
1 | 1 | 0 | 1 | x
1 | 1 | 1 | 0 | x
1 | 1 | 1 | 1 | x

L'exemple n'est pas totalement fortuit. Il s'agit en fait de la table de vérité servant au codage de la barre située en bas à gauche d'un afficheur 7 segments (allumée quand on souhaite afficher 0, 2, 6 ou 8, éteinte quand on a comme code 1, 3, 4, 5, 7 ou 9 et indéterminée pour les codes supérieurs à 9). L'expression de S s'écrit donc

Étape n°1 : Identification des termes générateurs

Pour identifier les termes générateurs, on remplit un premier tableau de la manière suivantes : 1°) Dans la première colonne, on écrit tous les termes portant la fonction à 1 ou à une forme indéterminée. Les termes sont triés en fonction du nombre de 1 qu'ils contiennent.

Colonne 0
0000
0010
1000
0110
1010
1100
1011
1101
1110
1111

On tente alors de combiner les termes afin d'éliminer ceux qui ne sont pas générateurs. L'intérêt de les avoir triés en fonction du nombre de 1 qu'ils contiennent permet de simplifier cette étape. Dans la colonne 0, on raye tour à tour les termes utilisés dans une recombinaison et on inscrit dans la colonne 1 du tableau les termes issues de ces recombinaisons.

  • 0000 peut être recombiné avec 0010 pour former le terme 00x0.
  • 0000 peut être recombiné avec 1000 pour former le terme x000.
  • 0010 peut être recombiné avec 1010 pour former le terme x010.
  • etc ...
Colonne 0 | Colonne 1
0000 | 00x0
0010 | x000
1000 | 0x10
0110 | x010
1010 | 10x0
1100 | 1x00
1011 | x110
1101 | 101x
1110 | 1x10
1111 | 110x
 | 11x0
 | 111x
 | 11x1
 | 1x11

On réitère alors cette opération avec les termes de la Colonne 1 : dans la colonne 0, on raye tour à tour les termes utilisés dans une recombinaison et on inscrit dans la colonne 2 du tableau les termes issues de ces recombinaisons. Ces termes sont composés de 2 x.

  • 00x0 peut être recombiné avec 10x0 pour former le terme x0x0.
  • x000 peut être recombiné avec x010 pour former le terme x0x0.
  • 0x10 peut être recombiné avec 1x10 pour former le terme xx10.
  • etc ...
  • x110 peut être recombiné avec x010 pour former le terme xx10.
Colonne 0 | Colonne 1 | Colonne 2
0000 | 00x0 | x0x0
0010 | x000 | xx10
1000 | 0x10 | 1xx0
0110 | x010 | 1x1x
1010 | 10x0 | 11xx
1100 | 1x00
1011 | x110
1101 | 101x
1110 | 1x10
1111 | 110x
 | 11x0
 | 111x
 | 11x1
 | 1x11

On réitère ce mécanisme jusqu'à ce qu'on ne puisse plus combiner de termes. Dans ce cas, tous les termes de la colonne 2 sont générateur, mais dans d'autre cas de figure, on pourrait trouver une colonne 3 avec des termes portant 3x.

Colonne 0 | Colonne 1 | Colonne 2
0000 | 00x0 | x0x0
0010 | x000 | xx10
1000 | 0x10 | 1xx0
0110 | x010 | 1x1x
1010 | 10x0 | 11xx
1100 | 1x00
1011 | x110
1101 | 101x
1110 | 1x10
1111 | 110x
 | 11x0
 | 111x
 | 11x1
 | 1x11

On a donc identifié 5 termes générateur : x0x0, xx10, 1xx0, 1x1x et 11xx.

Étape n°2 : Suppression des redondances

Pour identifier les termes redondants, on remplit un second tableau de la manière suivante : - en colonne, on retrouve les termes générateurs - en ligne, on retrouve les termes à exprimer (uniquement ceux de l'expression R puisque les cas indéterminés ne sont pas à coder). - dans les cases, on identifie quel terme générateur est utilisé pour écrire le terme à exprimer.

 | x0x0 | xx10 | 1xx0 | 1x1x | 11xx
0000 | X |  |  |  |
0010 | X | X |  |  |
0110 |  | X |  |  |
1000 | X |  | X |  |

Le terme x0x0 est à conserver car il est indispensable pour exprimer 0000. Le terme xx10 est à conserver car il est indispensable pour exprimer 0110. x0x0 et xx10 sont nécessaires. De plus, ils sont suffisants : ils réalisent déjà tous les termes de R.

1xx0 ne réalise rien de nouveau ; 1x1x et 11xx n'expriment que des termes de [image] , ils sont donc également considérés comme redondants.

Résultat final

Les termes conservés étant [image] et [image] , on obtient :


Multivibrateur — Wikipédia

Multivibrateur

Un article de Wikipédia, l'encyclopédie libre.

Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références » (modifier l'article, comment ajouter mes sources ?).

Un multivibrateur est un oscillateur électronique dont un seul élément[Contradiction] stocke les charges qui circulent dans le circuit.

Sommaire

1 Types de multivibrateurs

    • 1.1 Le multivibrateur astable

    • 1.2 Le multivibrateur monostable

    • 1.3 Le multivibrateur bistable

  • 2 Notes et références

  • 3 Voir aussi

    • 3.1 Article connexe

Types de multivibrateurs

Le multivibrateur astable

Exemple de schéma de multivibrateur astable

Le multivibrateur astable oscille en permanence entre deux états[1]

Ci-contre un exemple de schéma de multivibrateur astable. Les sorties sont situées au niveau du collecteur de Q1 et de Q2. Si l'on néglige les temps de montée, le signal de sortie produit par le multivibrateur est un signal carré.

Les sorties sont inversées l'une par rapport à l'autre. La durée de l'état 1 (sortie à l'état bas) est relié à la constante R2C1 correspondant à la charge de C1, et la durée de l'état 2 (sortie à l'état haut) sera reliée à R3C2 correspondant à la charge de C2. Vu qu'ici les charges des condensateurs sont indépendantes, il est aisé d'obtenir un rapport cyclique différent.

La tension aux bornes d'un condensateur avec une charge initiale non nulle est donnée par : V cap ( t ) = ( ( V capinit − V charge ) × e − t / ( R C ) ) + V charge {\displaystyle V_{\text{cap}}(t)=\left((V_{\text{capinit}}-V_{\text{charge}})\times e^{-t/(RC)}\right)+V_{\text{charge}}}

En regardant C2, juste avant que Q2 commute, la patte gauche de C2 est au potentiel base-émetteur de Q1 (VBE_Q1) et sa patte droite est à VCC ("VCC" est utilisé ici à la place de "+V" pour faciliter la lecture). La tension aux bornes de C2 est VCC moins VBE_Q1 . Juste après la commutation de Q2, la patte droite de C2 est maintenant à 0 V ce qui conduit l'autre patte de C2 à 0 V moins (VCC - VBE_Q1) ou VBE_Q1 - VCC. À cet instant, la patte gauche de C2 doit se charger de nouveau jusqu'à VBE_Q1. C'est le temps de cette charge qui va fixer la moitié de la période du multivibrateur (l'autre provenant de C1, est suivant le même raisonnement). Dans l'équation de charge d'un condensateur présentée au-dessus, en remplaçant les variables : V cap ( t ) {\displaystyle V_{\text{cap}}(t)} par VBE_Q1, V capinit {\displaystyle V_{\text{capinit}}} par (VBE_Q1 - VCC) et V charge {\displaystyle V_{\text{charge}}} par VCC on obtient : V BE _ Q1 = ( ( ( V BE _ Q1 − V CC ) − V CC ) × e − t / ( R C ) ) + V CC {\displaystyle V_{{\text{BE}}\_{\text{Q1}}}=\left(((V_{{\text{BE}}\_{\text{Q1}}}-V_{\text{CC}})-V_{\text{CC}})\times e^{-t/(RC)}\right)+V_{\text{CC}}}.

Ce qui nous donne une équation pour t : t = − R C × ln ⁡ ( V BE _ Q1 − V CC V BE _ Q1 − 2 V CC ) {\displaystyle t=-RC\times \ln \left({\frac {V_{{\text{BE}}\_{\text{Q1}}}-V_{\text{CC}}}{V_{{\text{BE}}\_{\text{Q1}}}-2V_{\text{CC}}}}\right)}

Pour que ce circuit fonctionne, VCC>>VBE_Q1 (par exemple: VCC=5 V, VBE_Q1=0,6 V), on peut alors simplifier l'équation précédente : t = − R C × ln ⁡ ( − V CC − 2 V CC ) {\displaystyle t=-RC\times \ln \left({\frac {-V_{\text{CC}}}{-2V_{\text{CC}}}}\right)} ou t = − R C × ln ⁡ ( 1 2 ) {\displaystyle t=-RC\times \ln \left({\frac {1}{2}}\right)} ou t = R C × ln ⁡ ( 2 ) {\displaystyle t=RC\times \ln(2)}

La période de chaque «moitié» du multivibrateur est alors donnée par : t = ln(2)RC.

Une des plus célèbres réalisations de multivibrateur astable en technologie TTL est le circuit intégré NE555 (1970).

Le multivibrateur monostable

Exemple de schéma de multivibrateur monostable

Un multivibrateur monostable peut avoir en sortie deux états : haut ou bas.

Une courte impulsion négative sur son entrée active la sortie à l'état haut, qui va revenir à son état initial après une période de temps déterminée par le temps de charge du condensateur. Si, toutefois, l'impulsion négative est maintenue, la sortie ne pourra pas revenir à son état initial. Elle y retournera une fois l'impulsion négative arrêtée.

Le multivibrateur bistable

Exemple de schéma de multivibrateur bistable (R1, R2 = 1 kΩ, R3, R4 = 10 kΩ).

Un multivibrateur bistable est un type de circuit dont la sortie change d'état lors de la modification de l'état d'une de ses entrées et qui garde cette position jusqu'à ce qu'un nouveau signal vienne rétablir la sortie à son niveau d'origine.

Ce type de circuit possède deux entrées et une ou deux sorties. Les entrées sont nommées Set et Reset. L'activation de Set modifie l'état de la sortie, alors que l'activation de Reset la renvoie à son état d'origine.

Tous les multivibrateurs possèdent un état interdit, c’est-à-dire un état dans lequel le multivibrateur ne doit pas être. Cet état est créé lorsque l'entrée Set et l'entrée Reset sont actionnées en même temps.

Notes et références

  1. ↑ Définitions lexicographiques [archive] et étymologiques [archive] de « Multivibrateur » du Trésor de la langue française informatisé , sur le site du Centre national de ressources textuelles et lexicales


Microcontrôleur — Wikipédia

Microcontrôleur

Un article de Wikipédia, l'encyclopédie libre.

1Le Motorola 68HC11, ici en boîtier PLCC, est un microcontrôleur réputé.

Un microcontrôleur (en notation abrégée µc, ou uc ou encore MCU en anglais) est un circuit intégré qui rassemble les éléments essentiels d'un ordinateur : processeur, mémoires (mémoire morte pour le programme, mémoire vive pour les données), unités périphériques et interfaces d'entrées-sorties. Les microcontrôleurs se caractérisent par un plus haut degré d'intégration, une plus faible consommation électrique, une vitesse de fonctionnement plus faible (de quelques mégahertz jusqu'à plus d'un gigahertz[1]) et un coût réduit par rapport aux microprocesseurs polyvalents utilisés dans les ordinateurs personnels.

Par rapport à des systèmes électroniques à base de microprocesseurs et autres composants séparés, les microcontrôleurs permettent de diminuer la taille, la consommation électrique et le coût des produits. Ils ont ainsi permis de démocratiser l'utilisation de l'informatique dans un grand nombre de produits et de procédés.

Les microcontrôleurs sont fréquemment utilisés dans les systèmes embarqués, comme les contrôleurs des moteurs automobiles, les télécommandes, les appareils de bureau, l'électroménager, les jouets, la téléphonie mobile, etc.

Sommaire

1 Introduction : le domaine visé, les systèmes embarqués

  • 2 Du microprocesseur au microcontrôleur

  • 3 Composants intégrés

  • 4 Architecture

  • 5 Utilisations et volume du marché

  • 6 Environnements de programmation

  • 7 Familles de microcontrôleurs

  • 8 Notes et références

Introduction : le domaine visé, les systèmes embarqués

La plus grande partie des systèmes électroniques complexes utilisés de nos jours sont des systèmes embarqués : téléphones mobiles, horloges, baladeurs, récepteurs GPS, électroménager, automobile, transport aérien/maritime/fluvial. Les systèmes embarqués se démarquent des systèmes informatiques traditionnels selon plusieurs aspects :

  • Ils sont soumis à des contraintes de taille (intégration), de consommation électrique (autonomie) et de coût importantes (grande série) ;

  • Ils sont en général assignés à une tâche bien précise. La taille des programmes et la quantité de mémoire (vive et morte), dont ils disposent, sont modestes (face à un micro-ordinateur) ;

  • Ils doivent communiquer avec des dispositifs d'entrées-sorties (IO) : boutons, relais, résistances variables, optocoupleurs, moteurs électriques, LED, circuits intégrés logiques, etc. ;

  • Ils n'ont parfois aucun dispositif d'interface homme-machine : ni clavier, ni écran, ni disque, ni imprimante, etc. Par exemple, le contrôleur d'injection de carburant du moteur d'une automobile est totalement invisible pour le conducteur.

Du microprocesseur au microcontrôleur

Le processeur est l'élément central d'un système informatique : il interprète les instructions et traite les données d'un programme. Il a besoin de certains éléments externes pour fonctionner :

  • une horloge pour le cadencer (en général à quartz ou Boucle à verrouillage de phase (PLL : Phase-Locked Loop)) ;

  • de la mémoire pour stocker les variables durant l’exécution du programme (mémoire vive RAM) et le programme d’une mise sous tension à l’autre (mémoire morte ROM). Si l'on conçoit un système assigné à une tâche bien particulière (ce qui est généralement le cas des systèmes embarqués), le programme n'est pas amené à changer. Il peut donc être stocké dans une mémoire morte (ROM) ;

  • des périphériques (pour interagir avec le monde extérieur).

Ces éléments sont reliés par 3 bus :

  • le bus d'adresse qui permet au microprocesseur de sélectionner la case mémoire ou le périphérique auquel il veut accéder pour lire ou écrire une information (instruction ou donnée) ;

  • le bus de données qui permet le transfert des informations entre les différents éléments ; ces informations seront soit des instructions, soit des données en provenance ou à destination de la mémoire ou des périphériques ;

  • le bus de contrôle qui indique si l'opération en cours est une lecture ou une écriture, si un périphérique demande une interruption pour faire remonter une information au processeur, etc.

Structure d'un système à microprocesseur

Traditionnellement, ces composants sont intégrés dans des circuits distincts. Le développement d'un tel système à base de microprocesseur se trouve donc pénalisé par (liste non exhaustive) :

  • la nécessité de prévoir l'interconnexion de ces composants (bus, câblage, nappes de connexion) ;

  • la place occupée physiquement par les composants et les moyens d'interconnexion ;

  • la consommation énergétique ;

  • la chaleur dégagée ;

  • le coût financier.

Les microcontrôleurs améliorent l'intégration et le coût (lié à la conception et à la réalisation) d'un système à base de microprocesseur en rassemblant ces éléments essentiels dans un seul circuit intégré. Un microcontrôleur est donc un composant autonome, capable d'exécuter le programme contenu dans sa mémoire morte dès qu'il est mis sous tension. Selon les modèles et les conditions de fonctionnement, les microcontrôleurs peuvent avoir besoin de quelques composants externes (quartz, quelques condensateurs, parfois une ROM), mais ceci reste très limité.

Lorsque toutes les fonctions du système informatique sont regroupées dans un unique circuit intégré, y compris les fonctions logiques, analogiques, radiofréquence, d'interface (USB, Ethernet, etc.), on parle alors de System on Chip (système sur puce ou système mono-puce). Ces composants sont basés sur un ou plusieurs cœurs de microcontrôleur, microprocesseur, processeur graphique, DSP, contrôleur de périphériques, etc….

Composants intégrés

Le circuit intégré d'un Intel 8742, un microcontrôleur 8 bits qui comprend un processeur cadencé à 12 MHz, 128 octets de mémoire vive, une EPROM de 2 048 bits, et des entrées-sorties sur une unique puce.

Un microcontrôleur intègre sur un unique die :

  • un processeur (CPU), avec une largeur du chemin de données allant de 4 bits pour les modèles les plus basiques à 32 ou 64 bits pour les modèles les plus évolués ;

  • de la mémoire vive (RAM) pour stocker les données et variables ;

  • de la mémoire morte (ROM) pour stocker le programme. Différentes technologies peuvent être employées : EPROM, EEPROM, mémoire flash (la plus récente) ;

  • souvent un oscillateur pour le cadencement. Il peut être réalisé avec un quartz, un circuit RC ou encore une PLL ;

  • des périphériques, capables d'effectuer des tâches spécifiques. On peut mentionner entre autres :

    • les convertisseurs analogiques-numériques (CAN) (donnent un nombre binaire à partir d'une tension électrique),

    • les convertisseurs numériques-analogiques (CNA) (effectuent l'opération inverse),

    • les générateurs de signaux à modulation de largeur d'impulsion (MLI, ou en anglais, PWM pour Pulse Width Modulation),

    • les timers/compteurs (compteurs d'impulsions d'horloge interne ou d'événements externes),

    • les chiens de garde (watchdog),

    • les comparateurs (comparent deux tensions électriques),

    • les contrôleurs de bus de communication (UART, I 2C , SSP, CAN, FlexRay, USB, Ethernet, etc.).

Ces PIC (microcontrôleurs de la marque Microchip) intègrent des quantités de composants très différentes.

Le fonctionnement des périphériques peut être paramétré et commandé par le programme et/ou les entrées-sorties. Les périphériques peuvent générer une interruption qui contraint le processeur à quitter le programme en cours pour effectuer une routine de traitement de l’interruption, lorsque l’événement qui la déclenche survient.

Les microcontrôleurs peuvent généralement se placer dans un état de sommeil, dans lequel ils présentent une très faible consommation électrique. Un signal envoyé par l'un de leurs périphériques (timer, broche d'entrée-sortie, watchdog, etc.) permet de les faire sortir de cet état de sommeil.

Certains microcontrôleurs ont un nombre très restreint de broches, si bien qu'une broche donnée peut correspondre à plusieurs périphériques internes. La fonction choisie doit alors être sélectionnée par logiciel.

Le choix des périphériques à intégrer dans un microcontrôleur est délicat. Les fabricants doivent réaliser un compromis entre des besoins contradictoires : utiliser des fréquences élevées, réduire la taille du circuit, apporter des fonctionnalités nombreuses, élaborer une architecture flexible, assurer des coûts modérés, etc.

Architecture

Un microcontrôleur peut effectuer la plupart des instructions machine habituelles, avec certaines restrictions liées à son caractère embarqué (taille restreinte des mots machine, petite taille disponible, etc.). On note cependant quelques particularités.

Les capacités mathématiques sont en général particulièrement limitées, réduites à des additions, soustractions et décalages sur des octets pour les plus simples d'entre eux. Les calculs mathématiques évolués doivent donc être ramenés à une succession d'opérations simples portant seulement sur des octets. Des routines mathématiques (petits programmes permettant de réaliser les calculs complexes) ont été développées pour la plupart des microcontrôleurs populaires.

Les instructions d'entrée-sortie sont bien développées, de façon à pouvoir :

  • lire l'état d'un port d'entrée ;

  • écrire une information dans le registre d'un port de sortie, qui maintient l'information à la disposition des circuits extérieurs.

Les microcontrôleurs disposent généralement de nombreuses instructions destinées aux opérations sur les bits, de façon à rendre les programmes plus compacts, notamment lorsqu'ils agissent sur une entrée-sortie donnée. Ainsi, un processeur généraliste peut avoir besoin de plusieurs instructions pour tester la valeur d'un bit d'un registre et effectuer un saut si le bit vaut vrai. Cette fonction courante est assurée par une seule instruction dans certains microcontrôleurs[2].

Les modes d'adressage utilisables sont en général semblables à ceux des autres processeurs.

De façon générale, les instructions et modes d'adressage disponibles varient fort selon les familles de microcontrôleurs.

Certains microcontrôleurs suivent une architecture Harvard [3] : ils possèdent des bus séparés pour la mémoire de programme et la mémoire de données, ce qui permet aux accès d'avoir lieu en même temps (on parle d'accès concurrent). Lorsqu'on utilise une architecture Harvard, les mots de programme peuvent avoir une largeur (nombre de bits) différente de celle des mots de la mémoire de données et des registres. Par exemple, il peut y avoir des instructions de 12 bits et des registres de données de 8 bits.

Utilisations et volume du marché

Les microcontrôleurs sont très utilisés dans tous les systèmes embarqués évoqués en introduction. Ils sont également très prisés en robotique amateur (robots autonomes) et en modélisme (automatismes des maquettes de réseaux ferroviaires par exemple).

Les microcontrôleurs représentent la plus grosse partie des ventes dans le marché des microprocesseurs [réf. nécessaire]. En effet, un foyer moyen d'un pays développé est susceptible d'être équipé de seulement un ou deux microprocesseurs généralistes (ordinateurs), mais d'une ou deux douzaines de microcontrôleurs (appareils électroménagers). Une automobile de milieu de gamme est équipée d'au moins 50 microcontrôleurs[réf. nécessaire].

Microcontrôleur ST6 équipé d'une mémoire EPROM effaçable aux UV.

Les fabricants proposent souvent des versions spéciales de leurs microcontrôleurs pour faciliter le développement matériel et logiciel des applications. Par exemple, lorsque les mémoires mortes utilisées étaient des EPROM, il existait des variantes des microcontrôleurs équipées de fenêtres sur le dessus, qui permettaient d'effacer le programme grâce à de la lumière ultraviolette. Ceci permettait de recommencer une programmation après un cycle programmation-test.

Pour de petites séries (quelques milliers d'unités ou moins), les microcontrôleurs programmables une seule fois (OTP, one-time programmable) sont économiques. Ils sont basés sur la même puce que la version UV-EPROM, se programment avec le même matériel, mais le boîtier n'est pas équipé de la fenêtre qui permet l'effacement (et qui est onéreuse).

Il peut exister des versions de microcontrôleurs dépourvus de mémoire morte interne. La mémoire morte est alors située dans un boîtier extérieur, par exemple une EPROM. Il suffit alors d'un simple programmateur d'EPROM pour réaliser la programmation, mais des broches du microcontrôleur sont requises pour la communication avec la mémoire externe, et ne peuvent donc pas être utilisées pour les entrées-sorties. Ces versions sont plus coûteuses, mais peuvent se révéler intéressantes si les quantités visées sont faibles.

Plus rarement, on rencontre une variante de l'approche précédente, le piggy back. Le microcontrôleur ne dispose pas non plus de mémoire morte interne, mais la communication avec l’EPROM se fait non pas par des broches d'entrée-sortie, mais par des broches spéciales situées sur le dessus du boîtier. L’EPROM se fixe alors au-dessus du microcontrôleur, et ne monopolise pas de port d'entrée-sortie. Ces versions sont souvent onéreuses et peu pratiques, sauf pour les phases de développement et les très petites séries.

Le recours à la programmation sur place, dans le circuit applicatif, permet de mettre à jour le programme après la fabrication du produit. On parle alors de flashage. Cette opération peut être effectuée via un programme situé en ROM, ou passer par l'utilisation d'un connecteur physique particulier. Dans tous les cas, on évite ainsi un retour en usine pour effectuer la mise à jour.

Lorsqu'il s'agit de produire de plus grandes séries (plusieurs milliers et plus), le coût de réalisation d'un masque pour la fabrication de mémoire morte non programmable est facilement amorti sur tous les exemplaires produits. On peut alors fixer le contenu de la mémoire morte lors de la réalisation du circuit intégré, et non plus lors du montage du produit. Cependant, ces mémoires présentent l'inconvénient de ne pouvoir être mises à jour. Si l'on envisage néanmoins de telles mises à jour, on peut prévoir de monter le microcontrôleur sur un support, ce qui permet de le faire remplacer par un technicien en cas de nécessité.

Environnements de programmation

Le programme d'un microcontrôleur est généralement appelé micrologiciel .

À l'origine, les microcontrôleurs se programmaient en assembleur. Fortement bas niveau (et donc, intrinsèquement optimisé), l'assembleur posa et pose toujours d'énormes problèmes pour la maintenance et l'évolution des logiciels embarqués. Désormais, on utilise de plus en plus des langages de haut niveau, notamment le langage C, capable de faciliter la programmation de microcontrôleurs toujours plus puissants. Ces compilateurs C présentent généralement certaines restrictions liées aux spécificités des microcontrôleurs (mémoire limitée, par exemple). Le compilateur GCC peut produire du code pour certains microcontrôleurs[4]. Avec l’augmentation de la puissance et de la quantité de mémoire de stockage (FLASH) disponible dans les microcontrôleurs, les programmes de ces derniers peuvent désormais être écrits en C++. Il existe même des frameworks et plateformes en C++ destinés à l’embarqué, comme Qtopia, mais l'utilisation de ceux-ci restera limitée aux microcontrôleurs les plus puissants.

Certains microcontrôleurs disposent également de firmware réalisant l'interprétation d'un langage évolué. Ainsi, l’Intel 8052 et le Zilog Z8 ont pu être programmés en BASIC dès leurs débuts. Plus récemment, le BASIC Stamp dispose d'un interprète BASIC en mémoire morte.

Il existe des environnements pour aider au développement de certaines applications. Par exemple, LabVIEW et son langage G permettent de programmer les microcontrôleurs Blackfin d'Analog Devices.

Des simulateurs sont disponibles pour certains microcontrôleurs, comme l'environnement MPLAB de Microchip. Les développeurs peuvent ainsi analyser le comportement du microcontrôleur et du programme, comme s'il s'agissait du composant réel. Un simulateur montre l'état interne du processeur, ainsi que celui de ses sorties. Bien que la plupart des simulateurs ne proposent pas de simuler les autres composants d'un système, ils permettent de spécifier les entrées à volonté. On peut de cette façon créer des conditions qui seraient sans cela difficiles à reproduire dans une implémentation physique. Cela facilite donc l'analyse et la résolution des problèmes. De la même façon, certains logiciels de CAO simulent le comportement du microcontrôleur et des composants qui l'entourent. On peut ainsi afficher les états des entrées et sorties des différents composant au cours de l'exécution d'un programme.

Programmateur de microcontrôleur PIC.

Une fois le programme compilé, le fichier binaire doit être envoyé au microcontrôleur. On utilise soit :

  • un programmateur, pour microcontrôleurs et souvent également d’EEPROM. On parle alors de programmateur universel.

  • un programmateur ISP qui a l'avantage de ne pas nécessiter de sortir le microcontrôleur du système électronique complet. Ce type de programmation pourra se faire via le bus de communication standard JTAG ou un autre bus, souvent propriétaire (Microchip par ex. avec sa série PIC16F) et, malheureusement, inadapté au test des cartes lors de la phase de production.

Toutefois, le programme qui a été envoyé peut comporter des bogues (bugs), aussi, pour parvenir à les détecter on peut utiliser un émulateur in-circuit.

Le projet μCLinux vise à faire fonctionner Linux sur des microcontrôleurs et des microprocesseurs dépourvus de MMU. Il est par exemple disponible sur Motorola ColdFire, Blackfin, Intel i960, Motorola QUICC, ARM7-TDMI, NEC V850.

Familles de microcontrôleurs

  • la famille Atmel AT91 ;

  • la famille Atmel AVR (utilisée par des cartes Wiring et Arduino) ;

  • le C167 de Siemens/Infineon ;

  • la famille Hitachi H8 ;

  • la famille Intel 8051, qui ne cesse de grandir ; de plus, certains processeurs récents utilisent un cœur 8051, qui est complété par divers périphériques (ports d’E/S, compteurs/temporisateurs, convertisseurs A/N et N/A, chien de garde, superviseur de tension, etc.) ;

  • l’Intel 8085, à l'origine conçu pour être un microprocesseur, a en pratique souvent été utilisé en tant que microcontrôleur ;

  • le Freescale 68HC11 ;

  • la famille Freescale 68HC08 ;

  • la famille Freescale 68HC12 ;

  • la famille Freescale Qorivva MPC5XXX ;

  • la famille des PIC de Microchip ;

  • la famille des dsPIC de Microchip ;

  • la famille des ST6, ST7, STM8, ST10, STR7, STR9, STM32 de STMicroelectronics ;

  • la famille ADuC d'Analog Devices ;

  • la famille PICBASIC de Comfile Technology;

  • la famille MSP430 de Texas Instruments ;

  • la famille 8080, dont les héritiers sont le microprocesseur Zilog Z80 (désormais utilisé en tant que contrôleur dans l'embarqué) et le microcontrôleur Rabbit ;

  • la famille PSoC de Cypress ;

  • la famille LPC21xx ARM7-TDMI de Philips ;

  • la famille V800 de NEC ;

  • la famille K0 de NEC.

Notes et références

  1. ↑ Par exemple, le PIC10F200 [archive] de Microchip fonctionne à 4 MHz, le LPC 3131 [archive] de NXP fonctionne à 180 MHz.

  2. ↑ Par exemple, l'instruction BTFSS (« bit test file, skip if set ») sur PIC permet d'ignorer l'instruction suivante si un certain bit d'un registre est à 1

  3. ↑ Par exemple les PIC et les AVR.

  4. ↑ Voir : Host/Target specific installation notes for GCC [archive].


Liste des circuits intégrés de la série 7400 — Wikipédia

Liste des circuits intégrés de la série 7400

Un article de Wikipédia, l'encyclopédie libre.

Circuit intégré de la série 7400 à quatre portes logiques NAND. L'indication « 7645 » indique que le circuit a été fabriqué la 45e semaine de 1976.

La série des 7400[1],[2] est une famille de circuits intégrés dont la caractéristique est d'utiliser la technique TTL.

Néanmoins, depuis l'invention de cette série, de nombreuses autres techniques ont été inventées, qui reprennent cette nomenclature avec un code du type 74XY, où X est un code composé d'une ou plusieurs lettres indiquant la technique (par exemple S, LS, HC, ACT...) et Y reprend le code de la fonction originelle de la série TTL (par exemple un circuit 74ACT245 réalise la même fonction logique qu'un 74245, mais avec des performances différentes).

Le préfixe 54 (au lieu de 74) est utilisé pour les composants de classe « militaire »[3] (c'est-à-dire qui fonctionnent de -55°C à +125°).

Sommaire

1 Classement par numéro

    • 1.1 00 à 99

    • 1.2 100 à 199

    • 1.3 200 à 299

    • 1.4 300 à 399

    • 1.5 500 à 599

    • 1.6 600 à 999

    • 1.7 4000 à 4999

  • 2 Classement par fonctions intégrées

    • 2.1 Fonction ET

    • 2.2 Fonction tampon

    • 2.3 Fonction NON

    • 2.4 Fonction NON-ET (ou NAND)

    • 2.5 Fonction OU

    • 2.6 Fonction OU EXCLUSIF ( = XOR)

    • 2.7 Fonction NON-OU (ou NOR)

    • 2.8 Mémoire

    • 2.9 Décodage et conversion

    • 2.10 Bascules

    • 2.11 Calcul et comptage

    • 2.12 Verrou

    • 2.13 Délai

    • 2.14 Contrôleur de ligne

    • 2.15 Divers

  • 3 Notes

Classement par numéro

00 à 99

  • 7400 : quatre portes logiques NON-ET à deux entrées

  • 7401 : quatre portes logiques NON-ET à deux entrées avec sortie à collecteur ouvert

  • 7402 : quatre portes logiques NON-OU à deux entrées

  • 7403 : quatre portes logiques NON-ET à deux entrées avec sortie à collecteur ouvert (attribution des broches différentes de celle du 7401)

  • 7404 : six portes logiques inverseuses NON

  • 7405 : six portes logiques inverseuses NON avec sortie à collecteur ouvert

  • 7406 : six portes logiques inverseuses NON avec buffers et sortie à collecteur ouvert d'une protection de 30 volts

  • 7407 : six tampons avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7408 : quatre portes logiques ET à deux entrées

  • 7409 : quatre portes logiques ET à deux entrées avec sortie à collecteur ouvert

  • 7410 : trois portes logiques NON-ET à trois entrées

  • 7411 : trois portes logiques ET à trois entrées75

  • 7412 : trois portes logiques NON-ET à trois entrées avec sortie à collecteur ouvert

  • 7413 : deux portes logiques NON-ET à quatre entrées avec trigger de Schmitt

  • 7414 : six portes logiques inverseuses NON avec trigger de Schmitt

  • 7415 : trois portes logiques ET à trois entrées avec sortie à collecteur ouvert

  • 7416 : six portes logiques inverseuses NON avec buffer et sortie à collecteur ouvert d'une protection de 15 volts

  • 7417 : six tampons avec sortie à collecteur ouvert d'une protection de 15 volts

  • 7418 : deux portes logiques NON-ET à quatre entrées avec trigger de Schmitt

  • 7419 : six portes logiques inverseuses NON avec trigger de Schmitt

  • 7420 : deux portes logiques NON-ET à quatre entrées

  • 7421 : deux portes logiques ET à quatre entrées

  • 7422 : deux portes logiques NON-ET à quatre entrées avec sortie à collecteur ouvert

  • 7423 : Double porte NON-OU à 4 entrées avec validation

  • 7424 : quatre portes logiques NON-ET à deux entrées avec trigger de Schmitt

  • 7425 : Double porte NON-OU à 4 entrées avec validation

  • 7426 : quatre portes logiques NON-ET à deux entrées avec sortie à collecteur ouvert d'une protection de 15 volts

  • 7427 : trois portes logiques NON-OU à trois entrées

  • 7428 : quatre portes logiques NON-OU à deux entrées avec buffer

  • 7430 : une porte NON-ET à huit entrées

  • 7431 : six éléments de délai

  • 7432 : quatre portes logiques OU à deux entrées

  • 7433 : quatre portes logiques NON-OU à deux entrées avec buffers et sortie à collecteur ouvert

  • 7434 :

  • 7435 :

  • 7436 : quatre portes logiques NON-OU à deux entrées (attribution des broches différente de celle du 7402)

  • 7437 : quatre portes logiques NON-ET à deux entrées avec buffers

  • 7438 : quatre portes logiques NON-ET à deux entrées avec buffers et sortie à collecteur ouvert

  • 7439 : quatre portes logiques NON-ET à deux entrées avec buffers et sortie à collecteur ouvert

  • 7440 : deux portes logiques NON-ET à quatre entrées avec buffers

  • 7441 : décodeur BCD vers décimal

  • 7442 : décodeur BCD vers décimal

  • 7443 : décodeur 4 bits vers décimal incrémenté de 3 (3 à 12)

  • 7444 : décodeur 4 bits vers décimal code gray incrémenté de 3

  • 7445 : décodeur BCD vers décimal avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7446 : décodeur BCD à 7 segments avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7447 : décodeur BCD à 7 segments avec sortie à collecteur ouvert d'une protection de 15 volts

  • 7448 : décodeur BCD à 7 segments avec sortie à collecteur ouvert muni de résistance de tirage

  • 7449 : décodeur BCD à 7 segments avec sortie à collecteur ouvert

  • 7450 : deux combinaisons de portes logiques ET-OU-NON à deux entrées avec une porte extensible

  • 7451 : deux combinaisons de portes logiques ET-OU-NON à deux entrées

  • 7452 :

  • 7453 :

  • 7454 :

  • 7455 :

  • 7456 : Diviseur de fréquence de rapport 1/50

  • 7457 : Diviseur de fréquence de rapport 1/60

  • 7458 : deux compteurs décimaux sur 4 bits

  • 7459 : deux compteurs binaires sur 4 bits

  • 7460 : deux expandeurs à quatre entrées

  • 7461 : trois expandeurs à trois entrées

  • 7473 : deux bascules JK sur front avec remise à zéro

  • 7474 : bascule D avec preset et clear

  • 7475 : deux doubles bascules D à verrouillage par niveau

  • 7479 : deux bascules D

  • 7480 : Additionneur complet de 1 bit

  • 7481 :

  • 7482 : Additionneur complet de 2 bits

  • 7483 : Additionneur complet de 4 bits

  • 7484 : mémoire RAM de 16 bits

  • 7485 : Comparateur de magnitude 4 bits

  • 7486 : quatre portes logiques OU exclusif à deux entrées

  • 7487 :

  • 7488 : mémoire ROM de 256 bits

  • 7489 : mémoire RAM de 64 bits

  • 7490 : compteur BCD et bi-quinaire

  • 7491 : registre à décalage de 8 bits avec entrée et sortie série

  • 7492 : compteur diviseur par 12

  • 7493 : compteur binaire de 4 bits

100 à 199

  • 74123 : Double monostable.

  • 74132 : quatre portes logiques NON-ET à deux entrées avec trigger de Schmitt

  • 74136 : Quatre portes logiques OU exclusif à deux entrées avec sortie à collecteur ouvert

  • 74138 : Démultiplexeur 3 vers 8 bits

  • 74139 : Double démultiplexeur 2 vers 4 bits

  • 74163 : Compteur binaire de 4 Bits

  • 74180 : Générateur / calculateur de parité sur 8 bits

  • 74181 : unité arithmétique et logique de 4 bits

  • 74182 : Générateur de retenue anticipée

  • 74184 : Convertisseur BCD vers binaire

  • 74185 : Convertisseur binaire vers BCD

  • 74186 : Mémoire morte de 512 bits (64x8) avec sortie à collecteur ouvert

  • 74187 : Mémoire morte de 1024 bits (256x4) avec sortie à collecteur ouvert

  • 74191 : Compteur binaire de 4 bits haut/bas avec entrées asynchrones

200 à 299

  • 74238 : Démultiplexeur 3 vers 8 bits

  • 74240 : tampon inverseur 8 bits avec sortie à trois états.

  • 74241 : tampon 8 bits avec sortie à trois états.

  • 74244 : tampon 2x4 bits avec sortie à trois états.

  • 74245 : tampon bidirectionnel 8 bits avec sortie à trois états

  • 74260 : deux portes logiques NON-OU à cinq entrées

  • 74273 : octuple bascule D.

300 à 399

  • 74314 : mémoire RAM de 1024 bits

  • 74373 : verrou 8 bits à sortie 3 états.

500 à 599

Les codes en 5xx sont pour beaucoup des créations plus récentes qui reprennent des fonctions déjà existantes mais avec un brochage du boîtier différent et quelques autres caractéristiques fonctionnelles légèrement modifiées.

  • 74540 : tampon 8 bits fonctionnellement équivalent à un 74240.

  • 74541 : tampon 8 bits fonctionnellement équivalent à un 74241.

  • 74573 : verrou 8 bits fonctionnellement équivalent à un 74373.

  • 74598 : registre à décalage de 8 bits avec entrée en verrou transparent

  • 74599 : registre à décalage de 8 bits avec sortie en verrou transparent

600 à 999

Ces codes sont en général utilisés pour des fonctions plus spécialisées. Il est fréquent qu'il n'y ait qu'un seul fabricant à les proposer.

  • 74618 : Triple portes logiques NON-ET à quatre entrées avec trigger de Schmitt et sortie totem-pole

  • 74619 : Huit portes logiques inverseuses NON à quatre entrées avec trigger de Schmitt et sortie totem-pole

  • 74756 : Double contrôleur de ligne de 4 bits avec sortie inversée à collecteur ouvert

  • 74757 : Double contrôleur de ligne de 4 bits avec sortie à collecteur ouvert (1 entrée de contrôle inversée)

  • 74758 : Transmetteur-Récepteur de 4 bits avec sortie inversée à collecteur ouvert

  • 74759 : Transmetteur-Récepteur de 4 bits avec sortie à collecteur ouvert

  • 74760 : Double contrôleur de ligne de 4 bits avec sortie à collecteur ouvert (2 entrées de contrôle inversées)

  • 74800 : Triple portes logiques ET et NON-ET à quatre entrées

  • 74802 : Triple portes logiques OU et NON-OU à quatre entrées

  • 74804 : Six portes logiques NON-ET à deux entrées

  • 74805 : Six portes logiques NON-OU à deux entrées

  • 74808 : Six portes logiques ET à deux entrées

  • 74821 : Registre de 10 bits synchrone avec sortie à trois états

  • 74822 : Registre de 10 bits synchrone avec sortie inversée à trois états inversées

  • 74823 : Registre de 9 bits synchrone avec sortie à trois états avec réinitialisation

  • 74824 : Registre de 9 bits synchrone avec sortie inversée à trois états avec réinitialisation

  • 74825 : Registre de 8 bits synchrone avec sortie à trois états avec réinitialisation

  • 74826 : Registre de 8 bits synchrone avec sortie inversée à trois états avec réinitialisation

  • 74885 : Comparateur de magnitude 8 bits

  • 74888 : Processeur 8 bits en boîtier DIP

  • 74889 : Processeur 8 bits en boîtier QFP

  • 74890 : Microséquenceur en boîtier DIP

  • 74891 : Microséquenceur en boîtier QFP

4000 à 4999

Ces références sont des reprises fonctionnelles de la série CMOS 4000 qui ont été adoptées par la série TTL faute de réel équivalent dans cette dernière. Elles n'existent en pratique que dans les techniques CMOS ayant adopté la nomenclature TTL (74HC et dérivés).

  • 744075 : Trois portes logiques OU à trois entrées

  • 747266 : Quatre portes logiques NON-OU Exclusif à deux entrées

Classement par fonctions intégrées

Fonction ET

  • 7408 : quatre portes logiques ET à deux entrées

  • 7409 : quatre portes logiques ET à deux entrées avec sortie à collecteur ouvert

  • 7411 : trois portes logiques ET à trois entrées

  • 7415 : trois portes logiques ET à trois entrées avec sortie à collecteur ouvert

  • 7421 : deux portes logiques ET à quatre entrées

  • 74800 : Triple portes logiques ET et NON-ET à quatre entrées

  • 74808 : Six portes logiques ET à deux entrées

Fonction tampon

  • 7407 : six tampons avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7417 : six tampons avec sortie à collecteur ouvert d'une protection de 15 volts

  • 74240 : tampon inverseur 8 bits avec sortie à trois états.

  • 74241 : tampon 8 bits avec sortie à trois états.

  • 74244 : tampon 2x4 bits avec sortie à trois états.

  • 74245 : tampon bidirectionnel 8 bits avec sortie à trois états

  • 74540 : tampon 8 bits fonctionnellement équivalent à un 74240.

  • 74541 : tampon 8 bits fonctionnellement équivalent à un 74241.

Fonction NON

  • 7404 : six portes logiques inverseuses NON

  • 7405 : six portes logiques inverseuses NON avec sortie à collecteur ouvert

  • 7406 : six portes logiques inverseuses NON avec buffers et sortie à collecteur ouvert d'une protection de 30 volts

  • 7414 : six portes logiques inverseuses NON avec trigger de Schmitt

  • 7416 : six portes logiques inverseuses NON avec buffer et sortie à collecteur ouvert d'une protection de 15 volts

  • 7419 : six portes logiques inverseuses NON avec trigger de Schmitt

  • 74619 : Huit portes logiques inverseuses NON à quatre entrées avec trigger de Schmitt et sortie totem-pole

Fonction NON-ET (ou NAND)

  • 7400 : quatre portes logiques NON-ET à deux entrées

  • 7401 : quatre portes logiques NON-ET à deux entrées avec sortie à collecteur ouvert

  • 7403 : quatre portes logiques NON-ET à deux entrées avec sortie à collecteur ouvert (attribution des broches différentes de celle du 7401)

  • 7410 : trois portes logiques NON-ET à trois entrées

  • 7412 : trois portes logiques NON-ET à trois entrées avec sortie à collecteur ouvert

  • 7413 : deux portes logiques NON-ET à quatre entrées avec trigger de Schmitt

  • 7418 : deux portes logiques NON-ET à quatre entrées avec trigger de Schmitt

  • 7430 : une porte NON-ET à huit entrées

  • 7437 : quatre portes logiques NON-ET à deux entrées avec buffers

  • 7438 : quatre portes logiques NON-ET à deux entrées avec buffers et sortie à collecteur ouvert

  • 7439 : quatre portes logiques NON-ET à deux entrées avec buffers et sortie à collecteur ouvert

  • 7440 : deux portes logiques NON-ET à quatre entrées avec buffers

  • 74132 : quatre portes logiques NON-ET à deux entrées avec trigger de Schmitt

  • 74618 : Triple portes logiques NON-ET à quatre entrées avec trigger de Schmitt et sortie totem-pole

  • 74800 : Triple portes logiques ET et NON-ET à quatre entrées

  • 74804 : Six portes logiques NON-ET à deux entrées

Fonction OU

  • 7432 : quatre portes logiques OU à deux entrées

  • 74802 : Triple portes logiques OU et NON-OU à quatre entrées

  • 744075 : Trois portes logiques OU à trois entrées

Fonction OU EXCLUSIF ( = XOR)

  • 7486 : Quatre portes logiques OU exclusif à deux entrées

  • 74136 : Quatre portes logiques OU exclusif à deux entrées avec sortie à collecteur ouvert

Fonction NON-OU (ou NOR)

  • 7402 : quatre portes logiques NON-OU à deux entrées

  • 7423 : Double porte NON-OU à 4 entrées avec validation

  • 7425 : Double porte NON-OU à 4 entrées avec validation

  • 7427 : trois portes logiques NON-OU à trois entrées

  • 7428 : quatre portes logiques NON-OU à deux entrées avec buffer

  • 7433 : quatre portes logiques NON-OU à deux entrées avec buffers et sortie à collecteur ouvert

  • 7436 : quatre portes logiques NON-OU à deux entrées (attribution des broches différente de celle du 7402)

  • 74260 : deux portes logiques NON-OU à cinq entrées

  • 74802 : Triple portes logiques OU et NON-OU à quatre entrées

  • 74805 : Six portes logiques NON-OU à deux entrées

Mémoire

  • 7484 : mémoire RAM de 16 bits

  • 7488 : mémoire ROM de 256 bits

  • 7489 : mémoire RAM de 64 bits

  • 7491 : registre à décalage de 8 bits avec entrée et sortie série

  • 74186 : Mémoire morte de 512 bits (64x8) avec sortie à collecteur ouvert

  • 74187 : Mémoire morte de 1024 bits (256x4) avec sortie à collecteur ouvert

  • 74314 : mémoire RAM de 1024 bits

  • 74314 : mémoire RAM de 1024 bits

  • 74821 : Registre de 10 bits synchrone avec sortie à trois états

  • 74822 : Registre de 10 bits synchrone avec sortie inversée à trois états inversées

  • 74823 : Registre de 9 bits synchrone avec sortie à trois états avec réinitialisation

  • 74824 : Registre de 9 bits synchrone avec sortie inversée à trois états avec réinitialisation

  • 74825 : Registre de 8 bits synchrone avec sortie à trois états avec réinitialisation

  • 74826 : Registre de 8 bits synchrone avec sortie inversée à trois états avec réinitialisation

Décodage et conversion

  • 7441 : décodeur BCD vers décimal

  • 7442 : décodeur BCD vers décimal

  • 7443 : décodeur 4 bits vers décimal incrémenté de 3 (3 à 12)

  • 7444 : décodeur 4 bits vers décimal code gray incrémenté de 3

  • 7445 : décodeur BCD vers décimal avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7446 : décodeur BCD à 7 segments avec sortie à collecteur ouvert d'une protection de 30 volts

  • 7447 : décodeur BCD à 7 segments avec sortie à collecteur ouvert d'une protection de 15 volts

  • 7448 : décodeur BCD à 7 segments avec sortie à collecteur ouvert muni de résistance de tirage

  • 7449 : décodeur BCD à 7 segments avec sortie à collecteur ouvert

  • 74184 : Convertisseur BCD vers binaire

  • 74185 : Convertisseur binaire vers BCD

Bascules

  • 7473 : deux bascules JK sur front avec remise à zéro et sorties complémentaires

  • 7474 : bascule D avec preset et clear

  • 7479 : deux bascules D

  • 74273 : octuple bascule D

Calcul et comptage

  • 7458 : deux compteurs décimaux sur 4 bits

  • 7459 : deux compteurs binaires sur 4 bits

  • 7482 : additionneur complet de 2 bits

  • 7483 : additionneur complet de 4 bits

  • 7490 : compteur BCD et bi-quinaire

  • 7492 : compteur diviseur par 12

  • 7493 : compteur binaire de 4 bits

  • 74180 : Générateur / calculateur de parité sur 8 bits

  • 74181 : unité arithmétique et logique de 4 bits

  • 74182 : générateur de retenue anticipée

  • 74191 : Compteur binaire de 4 bits haut/bas avec entrées asynchrones

  • 74888 : Processeur 8 bits en boîtier DIP

  • 74889 : Processeur 8 bits en boîtier QFP

  • 74890 : Microséquenceur en boîtier DIP

  • 74891 : Microséquenceur en boîtier QFP

Verrou[modifier | modifier le code]

  • 74373 : verrou 8 bits à sortie 3 états.

  • 74573 : verrou 8 bits fonctionnellement équivalent à un 74373.

Délai[modifier | modifier le code]

  • 7431 : six éléments de délai

Contrôleur de ligne[modifier | modifier le code]

  • 74756 : Double contrôleur de ligne de 4 bits avec sortie inversée à collecteur ouvert

  • 74757 : Double contrôleur de ligne de 4 bits avec sortie à collecteur ouvert (1 entrée de contrôle inversée)

  • 74760 : Double contrôleur de ligne de 4 bits avec sortie à collecteur ouvert (2 entrées de contrôle inversées)

Divers[modifier | modifier le code]

  • 7450 : deux combinaisons de portes logiques ET-OU-NON à deux entrées avec une porte extensible

  • 7451 : deux combinaisons de portes logiques ET-OU-NON à deux entrées

  • 7456 : Diviseur de fréquence de rapport 1/50

  • 7457 : Diviseur de fréquence de rapport 1/60

  • 7460 : deux expandeurs à quatre entrées

  • 7461 : trois expandeurs à trois entrées

  • 7485 : Comparateur de magnitude 4 bits

  • 74758 : Transmetteur-Récepteur de 4 bits avec sortie inversée à collecteur ouvert

  • 74759 : Transmetteur-Récepteur de 4 bits avec sortie à collecteur ouvert

Notes[modifier | modifier le code]

  1. ↑ (en)Logic selection guide 2015 [archive], NXP Semiconductors N.V., January 2015, don 9397 750 17285

  2. ↑ J.C. Chauveau, G. Chevalier et B. Chevalier, Mémotech électronique, Éditions Casteilla, 1997 (ISBN 2-7135-1755-9), chap. 2.1 Série 74 TTL - CMOS rapides

  3. ↑ (en) R. M. Marston, Modern CMOS Circuits Manual, Newnes, 1996, 15-16 p. (ISBN 978-0-7506-2565-4, lire en ligne [archive])

Sur les autres projets Wikimedia :

  • Circuits intégrés de la série 7400, sur Wikimedia Commons

[masquer]

v · m

Électronique

Analogique

  • Alimentation électrique

  • Amplificateur :(Amplificateur de mesure et Amplificateur opérationnel)

  • Bobine

  • Capteur

  • Circuit intégré

  • Composants analogiques programmables (FPAA)

  • Commutateur

  • Condensateur

  • Diode

  • Filtre

  • Radiocommunication

  • Thyristor

  • Transistor

  • Triac

  • Tube

Numérique

  • ASIC

  • Circuit logique programmable (CPLD/EPLD/FPGA/PAL/PLA/PLD)

  • DSP

  • µContrôleur

  • µProcesseur

  • Ordinateur

  • Porte logique

Optoélectronique

  • Cellule photoélectrique

  • Cellule photovoltaïque

  • LED

  • Diode laser

  • OLED

  • Optocoupleur

  • Photodiode

Micro-électronique

MEMS

  • Automatique

  • Électricité

  • Électrochimie

  • Électromagnétisme

  • Électrotechnique

  • Robotique

  • Traitement du signal

  • Portail de l’électricité et de l’électronique Portail de l’électricité et de l’électronique

Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Liste_des_circuits_intégrés_de_la_série_7400&oldid=131258558 ».

Catégorie :

  • Circuit intégré logique

| [+]

Catégories cachées :

  • Catégorie Commons avec lien local identique sur Wikidata

  • Portail:Électricité et électronique/Articles liés

Menu de navigation

Outils personnels

  • Non connecté

  • Discussion

  • Contributions

  • Créer un compte

  • Se connecter

Espaces de noms

  • Article

  • Discussion

Variantes

Affichages

  • Lire

  • Modifier

  • Modifier le code

  • Historique

Plus

Rechercher

Navigation

  • Accueil

  • Portails thématiques

  • Article au hasard

  • Contact

Contribuer

  • Débuter sur Wikipédia

  • Aide

  • Communauté

  • Modifications récentes

  • Faire un don

Outils

  • Pages liées

  • Suivi des pages liées

  • Importer un fichier

  • Pages spéciales

  • Adresse permanente

  • Information sur la page

  • Élément Wikidata

  • Citer cette page

Imprimer / exporter

  • Créer un livre

  • Télécharger comme PDF

  • Version imprimable

Dans d’autres projets

  • Wikimédia Commons

Dans d’autres langues

  • Čeština

  • Deutsch

  • English

  • हिन्दी

  • Português

  • Slovenčina

  • Tiếng Việt

  • 中文

Modifier les liens

  • Dernière modification de cette page le 30 octobre 2016, à 20:55.

  • Droit d'auteur : les textes sont disponibles sous licence Creative Commons attribution, partage dans les mêmes conditions ; d’autres conditions peuvent s’appliquer. Voyez les conditions d’utilisation pour plus de détails, ainsi que les crédits graphiques. En cas de réutilisation des textes de cette page, voyez comment citer les auteurs et mentionner la licence.
    Wikipedia® est une marque déposée de la Wikimedia Foundation, Inc., organisation de bienfaisance régie par le paragraphe 501(c)(3) du code fiscal des États-Unis.

  • Politique de confidentialité

  • À propos de Wikipédia

  • Avertissements

  • Développeurs

  • Déclaration sur les témoins (cookies)

  • Version mobile

  • Powered by MediaWiki


Compteur — Wikipédia

Compteur

Un article de Wikipédia, l'encyclopédie libre.

D'une façon générale, on appelle compteur un système destiné à visualiser une grandeur, une quantité dans une unité précise.

Il s'agit en général de quantifier des grandeurs discrètes (numérique), mais l'usage courant a largement étendu le terme à des grandeurs comportant quelques chiffres après la virgule.

Exemple : le compteur kilométrique d'un véhicule affiche les distances parcourues par le dit véhicule en kilomètres tout en affichant la vitesse instantanée du véhicule.

Sommaire

1 Statistiques et surveillance de flux

  • 2 Mécanique

    • 2.1 Automobile

    • 2.2 Cyclisme

  • 3 Électromécanique

  • 4 Électronique

    • 4.1 Compteur binaire

    • 4.2 Compteur DCB ou décimal

    • 4.3 Compteur réversible

    • 4.4 Compteur à prédétermination

    • 4.5 Compteur asynchrone ou synchrone

    • 4.6 Biologie, physique

  • 5 Voir aussi

Statistiques et surveillance de flux

La détermination de statistiques nécessite la mesure d'un phénomène ; dans le cas d'un phénomène discret, il s'agit d'un dénombrement. Le problème se pose également dans la surveillance de flux, par exemple pour limiter le nombre de personnes situées dans un lieu (afin de limiter les problèmes lors d'une évacuation en cas de sinistre), pour surveiller la circulation routière (prévision d'embouteillages), pour gérer un flux de produits dans une chaîne de fabrication, ou bien d'une mesure physique (comptage du nombre de photons X, comptage du nombre de désintégrations), …

Lorsqu'il s'agit d'objets visibles à l'œil nu, la manière la plus simple à mettre en œuvre est le comptage par une personne, oral ou bien matériel (inscription de bâtons, utilisation de jetons), mais la méthode est limitée par les défaillances individuelles : fatigue, oubli, inattention. On peut assister l'humain d'un compteur manuel, ou utiliser des méthodes de type tickets numérotés.

On peut aussi faire une détection automatique. Il peut s'agir d'une action mécanique : un objet passe sur un tapis qui détecte la pression, le comptage peut alors être mécanique (similaire au compteur manuel) ou bien électronique (détection d'impulsions générées par un capteur). Il peut s'agir d'un détecteur optique : par exemple, un objet ou une personne coupe un faisceau lumineux (cellule photoélectrique), ou bien de l'association d'une caméra numérique et d'un logiciel d'analyse d'image, ou encore d'une mesure de diffusion de la lumière sur des particules (mesure de turbidité). Dans le cas d'un objet comportant une certaine quantité d'acier (par exemple un véhicule), il peut s'agir d'une détection magnétique.

Mécanique

Automobile

Articles détaillés : Odomètre et indicateur de vitesse.

Un câble contenu dans une gaine transfère une infime partie du couple destiné aux roues du véhicule à un mécanisme qui convertit la vitesse de rotation du câble en un affichage compréhensible par le conducteur. En général le mécanisme transforme ce déplacement (rotation) en un déplacement proportionnel angulaire d'une aiguille face à des graduations pour l'affichage de la vitesse et en rotation de plusieurs bagues indiquant les kilomètres parcourus.

Cyclisme

Article détaillé : Compteur de bicyclette .

Électromécanique

Compteur électrique

Article détaillé : Compteur électrique.

Un système combinant la mécanique pure et les effets électromagnétiques permet la visualisation d'une grandeur.

Électronique

En électronique, un compteur est un circuit intégré numérique destiné à compter le nombre d'impulsions appliquées à son entrée. Il est composé d'un certain nombre de bascules D, T ou JK.

Compteur binaire

Compteur binaire asynchrone

Le compteur le plus simple est obtenu en mettant en cascade une série de bascules T, le signal à compter étant appliqué à l'entrée de la première bascule ; la sortie de cette bascule pilote l'entrée de la deuxième bascule et ainsi de suite. Le résultat du comptage apparaît sous forme de nombre binaire, la première bascule indiquant le chiffre le moins significatif.

Exemple : 01010111 indique 87.

Il est généralement prévu une ligne (RAZ, remise à zéro ou Reset) permettant de remettre le compteur à 0 après un comptage.

La capacité du compteur, c'est le nombre maximum d'impulsions qu'il peut totaliser sans erreur. Elle vaut 2N pour un compteur binaire. Si l'on dépasse la capacité, le compteur revient à 0 et se remet à compter.

Pour éviter d'utiliser un résultat erroné, on peut adjoindre au compteur un indicateur de dépassement ; ce dernier est piloté par une bascule qui est activée lors d'un dépassement de capacité du compteur.

La fréquence maximale du signal qui peut être appliqué au compteur dépend de la technologie utilisée pour réaliser les bascules : TTL, CMOS, ECL etc.

Compteur DCB ou décimal

Le compteur binaire est le plus compact, c'est-à-dire celui qui nécessite le moins de bascules pour une capacité donnée. Tant qu'il s'agit de mémoriser les résultats dans une mémoire d'ordinateur, c'est un très bon choix. Mais si l'on souhaite un résultat sous une forme plus compréhensible pour l'utilisateur, on utilisera des compteurs DCB, souvent appelés abusivement compteurs décimaux. Les bascules sont groupées par 4, chaque groupe indiquant un chiffre décimal. Ce type de compteur est utilisé dans les appareils de mesure tels que voltmètre et multimètre numériques, fréquencemètre ...

Exemple : 0101 0111 indique 57

Compteur réversible

C'est un compteur, binaire ou décimal qui permet de compter ou décompter selon le niveau logique appliqué à une broche de commande appelée Sens de comptage (Up/down).

Compteur à prédétermination

C'est un compteur doté d'entrées permettant d'introduire un nombre quelconque dans le compteur (Chargement parallèle ou Parallel load). Une fois le nombre introduit, les impulsions appliquées à l'entrée de comptage vont incrémenter ou, le plus souvent, décrémenter le contenu du compteur.

Exemple : minuterie, où l'on sélectionne le nombre de minutes désiré, et le compteur revient progressivement vers 0.

Compteur asynchrone ou synchrone

Compteur binaire synchrone

Le compteur binaire décrit ci-dessus souffre d'un défaut lorsqu'il s'agit de mémoriser les résultats. En effet, comme chaque bascule met un certain temps pour changer d'état (ce qu'on appelle temps de propagation, noté tp), les différentes bascules réagissent non pas simultanément mais progressivement. Dans le cas extrême (celui où c'est la bascule à l'extrémité de la chaîne, celle qui indique le chiffre le plus significatif, qui doit changer d'état), il faut attendre un temps N.tp après l'impulsion pour avoir l'indication correcte. Si l'impulsion destinée à mémoriser le nombre dans un registre arrive après une impulsion mais avant l'expiration du délai N.tp, le résultat mis en mémoire est peut-être erroné.

Pour éviter ces problèmes, on modifie la façon de raccorder les bascules. On emploie des bascules JK. Les impulsions à totaliser sont appliquées simultanément aux entrées horloge de toutes les bascules. La première bascule, qui reçoit les impulsions, a ses entrées J et K en permanence à 1 ; elle change donc d'état à chaque impulsion ; les entrées des autres bascules sont pilotées par les sorties des bascules précédentes de façon à ce qu'elles basculent aux moments opportuns : chaque bascule est autorisée à basculer quand toutes les bascules précédentes ont leur sortie à 1.

Les compteurs où l'horloge est appliquée simultanément à toutes les bascules sont appelés compteurs synchrones (synchronous counters), les autres, compteurs asynchrones (asynchronous ou ripple counters).

Biologie, physique

Le domaine du Vivant comme celui de la physique utilise des matériels de détection et comptage de particules, mais aussi de cellules (dont spermatozoïdes par exemple), de chloroplastes, globules rouges ou blanc, etc. Ce comptage peut éventuellement être assisté ou effectué par des robots, logiciels de reconnaissance et analyse d'image.

Voir aussi

Sur les autres projets Wikimedia :

  • compteur, sur le Wiktionnaire

  • Compteur décompteur [archive]

  • Compteur d'eau

  • Registre à décalage à rétroaction linéaire (LFSR en anglais)

  • Code de Gray


Circuit intégré — Wikipédia

Circuit intégré

Un article de Wikipédia, l'encyclopédie libre.

Le circuit intégré (CI), aussi appelé puce électronique, est un composant électronique reproduisant une, ou plusieurs, fonction(s) électronique(s) plus ou moins complexe(s), intégrant souvent plusieurs types de composants électroniques de base dans un volume réduit (sur une petite plaque), rendant le circuit facile à mettre en œuvre.

Il existe une très grande variété de ces composants divisés en deux grandes catégories : analogique et numérique.

Carte à puce : carte contenant une puce (connecteur visible à gauche).

Sommaire

1 Historique

    • 1.1 Premières utilisations

    • 1.2 Circuit intégré analogique

    • 1.3 Circuit intégré numérique

  • 2 Composition

    • 2.1 Le boîtier

    • 2.2 Le Die

  • 3 Échelle d'intégration

  • 4 La technique de fabrication la plus courante

    • 4.1 Matière première

    • 4.2 La photolithogravure

      • 4.2.1 Étapes de fabrication

      • 4.2.2 Phases finales

  • 5 Industrie

  • 6 Écologie

  • 7 Notes et références

  • 8 Voir aussi

    • 8.1 Articles connexes

Historique

En 1958, l’américain Jack Kilby invente le premier circuit intégré[1] jetant ainsi les bases du matériel informatique moderne. Kilby a tout simplement relié entre eux différents transistors en les câblant à la main. Il ne faudra par la suite que quelques mois pour passer du stade de prototype à la production de masse de puces en silicium contenant plusieurs transistors. Ces ensembles de transistors interconnectés en circuits microscopiques dans un même bloc, permettaient la réalisation de mémoires, ainsi que d’unités logiques et arithmétiques. Ce concept révolutionnaire concentrait dans un volume incroyablement réduit, un maximum de fonctions logiques, auxquelles l'extérieur accédait à travers des connexions réparties à la périphérie du circuit. Cette découverte a valu à Kilby un prix Nobel de physique en 2000, alors que celui-ci siégeait toujours au directoire de Texas Instruments et détenait plus de 60 brevets à son nom.

Premières utilisations

Le programme de missile balistique Minuteman II a été essentiel au développement économique de l'industrie du circuit intégré. C'est le premier objet produit en série qui intégrait un ordinateur conçu à partir de ceux-ci (le D-37C (en) d'Autonetics), il a d'ailleurs été le seul consommateur de ce type d'ordinateur de 1962 à 1967. L'ordinateur comprenait des circuits fabriqués par Texas Instruments de types logique diode-transistor et logique diode. Le seul autre ordinateur qui a fait appel à cette technologie est celui destiné à contrôler les missions Apollo, ordinateur qui avait des contraintes semblables du point de vue de la masse et de la fiabilité.

Circuit intégré analogique

Les circuits intégrés analogiques les plus simples peuvent être de simples transistors encapsulés les uns à côté des autres sans liaison entre eux, jusqu'à des assemblages complexes pouvant réunir toutes les fonctions requises pour le fonctionnement d'un appareil dont il est le seul composant.

Les amplificateurs opérationnels sont des représentants de moyenne complexité de cette grande famille où l'on retrouve aussi des composants réservés à l'électronique haute fréquence et de télécommunication. De nombreuses applications analogiques sont à base d'ampli Op.

Circuit intégré numérique

Les circuits intégrés numériques les plus simples sont des portes logiques (et, ou et non), les plus complexes sont les microprocesseurs et les plus denses sont les mémoires. On trouve de nombreux circuits intégrés dédiés à des applications spécifiques (ou ASIC pour Application-specific integrated circuit), notamment pour le traitement du signal (traitement d'image, compression vidéo...) on parle alors de processeur de signal numérique (ou DSP pour Digital Signal Processor). Une famille importante de circuits intégrés est celle des composants de logique programmable (FPGA, CPLD). Ces composants sont amenés à remplacer les portes logiques simples en raison de leur grande densité d'intégration.

Composition

Le boîtier

Circuits intégrés boîtier DIP.

Un microcontrôleur boîtier DIP.

Les circuits intégrés se présentent généralement sous la forme de boîtiers pleins rectangulaires, noirs, équipés sur un ou plusieurs côtés voire sur une face, de 'pattes' (appelées aussi broches ou pins) permettant d'établir les connexions électriques avec l'extérieur du boîtier. Ces composants sont brasés, (soudé, terme impropre) sur un circuit imprimé, ou enfichés, à des fins de démontage, dans des supports eux-mêmes brasés sur un circuit imprimé.

Sur le boîtier peuvent être peint : le logo du fabricant, une référence qui permet d'identifier le composant, un code correspondant à des variantes ou révisions, la date de fabrication (4 chiffres codés AASS : année et semaine). Les progrès de l'intégration sont tels que les circuits intégrés peuvent devenir très petits. Leur taille ne dépend plus guère que de la capacité du boîtier à dissiper la chaleur produite par effet Joule et, bien souvent du nombre, de la taille des broches de sortie du circuit ainsi que de leur espacement.

Différents types de boîtiers permettent d'adapter le circuit intégré à son environnement de destination.

  • Le format le plus ancien a pour nom Dual Inline Package (DIP ou DIL) qui se traduit sommairement par « boîtier avec deux lignes ».

  • La miniaturisation aidant, les circuits dits de surface ont fait leur apparition : le format SO.

Bien d'autres types existent :

Article détaillé : boîtier de circuit intégré.

Le Die

Un die de circuit intégré VLSI

Le die est la partie élémentaire, de forme rectangulaire, reproduite à l’identique à l’aide d’une matrice sur une tranche de silicium en cours de fabrication. Il correspond a un circuit intégré qui sera ensuite découpé et que l’on appellera une puce avant qu’elle ne soit encapsulée pour donner un circuit intégré complet, prêt à être monté sur une carte.

Le Die d'un circuit intégré comprend sous des formes miniaturisées principalement des transistors, des diodes, des résistances, des condensateurs, plus rarement des inductances, car elles sont plus difficilement miniaturisables.

Article détaillé : Die (circuit intégré).

Échelle d'intégration

L'échelle d'intégration (en anglais scale integration) définit le nombre de portes logiques par boîtier :

Nom | Signification | Année de sortie | Nombre de transistors [2] | Nombre de portes logiques par boîtier[3]
SSI | small-scale integration | 1964 | 1 à 10 | 1 à 12
MSI | medium-scale integration | 1968 | 10 à 500 | 13 à 99
LSI | large-scale integration | 1971 | 500 à 20 000 | 100 à 9 999
VLSI | very large-scale integration | 1980 | 20 000 à 1 000 000 | 10 000 à 99 999
ULSI | ultra-scale integration | 1984[4] | 1 000 000 et plus | 100 000 et plus

Ces distinctions ont peu à peu perdu de leur utilité avec la croissance exponentielle du nombre de portes. Aujourd'hui plusieurs centaines de millions de transistors (plusieurs dizaines de millions de portes) représentent un chiffre normal (pour un microprocesseur ou un circuit intégré graphique haut de gamme). Afin de parvenir à de tels niveaux d'intégrations, un flot de conception complexe est utilisé.

La technique de fabrication la plus courante

Des microprocesseurs sur la tranche de silicium ( wafer ) qui sert à leur fabrication.

La fabrication d'un circuit intégré est un procédé complexe dont la tendance est à se compliquer de plus en plus.

  • Le motif de base est le transistor, et ce sont ensuite les interconnexions métalliques entre les transistors qui réalisent la fonction particulière du circuit.

  • L'aluminium est souvent employé dans ce but, mais une technologie plus performante permet l'emploi du cuivre, qui conduit mieux l’électricité et la chaleur.

  • On utilise parfois du silicium polycristallin, également conducteur, notamment pour la grille du transistor.

Matière première

La matière première de base habituellement utilisée pour fabriquer les circuits intégrés est le silicium, néanmoins, d'autres matériaux sont parfois employés, comme le germanium ou l'arséniure de gallium.

Le silicium est un semi-conducteur dans sa forme monocristalline. Ce matériau doit être pur à 99,99 %.

On fabrique d'abord un barreau cylindrique de silicium en le cristallisant très lentement. Ce barreau est ensuite découpé pour être utilisé sous forme de galettes de 100 à 800 μm d'épaisseur et ayant jusqu'à 300 mm de diamètre, appelé wafer (galette, en anglais). Un wafer va supporter de nombreux circuits intégrés.

La photolithogravure

Article détaillé : Photolithographie.

La photolithographie, désigne l'ensemble des opérations permettant de délimiter l'extension latérale des matériaux sur la surface d'un substrat semi-conducteur, dont la structure est plus ou moins bidimensionnelle car basée sur l'empilement de couches à la surface d'une plaquette de silicium. Les motifs deviendront par la suite les différentes zones actives des composants électroniques (exemple : contact, drain...) ou les jonctions entre ces composants. Ce procédé est actuellement le plus répandu.

Étapes de fabrication

Le circuit intégré d'une puce Intel 8742

Le nombre d'étapes de la fabrication des circuits intégrés a crû considérablement depuis 20 ans. Il peut atteindre plusieurs dizaines pour certaines productions spécialisées. Toutefois, on retrouve à peu près toujours la même série d'étapes :

  • Préparation de la couche : on expose le wafer à du dioxygène pur après chauffage pour fabriquer une couche d'oxyde (isolant) en surface, ensuite le wafer est recouvert d'un vernis photosensible.

  • Transfert : on transfère le dessin du circuit à reproduire sur la surface photosensible à l'aide d'un masque, comme pour la peinture au pochoir, en l'exposant aux ultraviolets, (ou aux rayons X, pour les gravures les plus fines). Le vernis non soumis aux rayonnements est dissous grâce à un solvant spécifique.

  • Gravure : l'oxyde de silicium est protégé par le vernis aux endroits exposés aux ultraviolets. Un agent corrosif va creuser la couche d'oxyde aux endroits non protégés.

  • Dopage : on dissout ensuite le vernis exposé avec un autre solvant, et des ions métalliques, appelés dopants, sont introduits dans le silicium exposé là où l'oxyde a été creusé, afin de le rendre conducteur.

  • Couche suivante : l'opération est renouvelée pour créer les couches successives du circuit intégré ou du microprocesseur (jusqu'à 13).

  • On détermine la qualité de la gravure selon le plus petit motif qu'il est possible de graver, en l'occurrence la largeur de la grille du transistor MOS.

    • En 2004, les gravures les plus fines en production sont de 0,13 μm (ou 130 nm) et 90 nm.

    • En 2006, les gravures les plus fines en production sont de 60 nm et 30 nm.

    • En 2015, les gravures les plus fines en production sont de 14 nm.

Phases finales

  • On dépose une pellicule métallique aux endroits où le circuit devra être en contact avec les broches de sortie.

  • Les circuits intégrés sont testés directement sur le wafer. Les puces défectueuses sont marquées (inking). Il s'agit de l’EWS.

  • Le wafer est finalement découpé au moyen d'une scie circulaire au diamant d'une épaisseur de 0,02 mm ou via un procédé de découpe laser pour obtenir des die .

  • Les puces ainsi obtenues sont insérées dans un boîtier individuel de protection et reliées aux broches qui vont leur permettre de communiquer avec l'extérieur.

  • Des tests de validation sévères et individuels sont alors entrepris pour qualifier les microprocesseurs, en fréquence et en température.

Industrie

Article détaillé : Liste des principaux fabricants de semi-conducteurs au fil des ans.

Les 20 plus importants fabricants de circuits intégrés en 2011 et leur part de marché sont (fonderies exclues) :

Rang 2011 | Rang 2010 | Société | Nationalité/localisation | Chiffre d'affaires (Million de $ USD) | 2011/2010 | Part de marché
1 | 1 | Intel Corporation (1) | Drapeau des États-Unis États-Unis | 49 685 | +23,0 % | 15,9 %
2 | 2 | Samsung Electronics | Drapeau de la Corée du Sud Corée du Sud | 29 242 | +3,0 % | 9,3 %
3 | 4 | Texas Instruments (2) | Drapeau des États-Unis États-Unis | 14 081 | +8,4 % | 4,5 %
4 | 3 | Toshiba Semiconductors | Drapeau du Japon Japon | 13 362 | +2,7 % | 4,3 %
5 | 5 | Renesas Technology | Drapeau du Japon Japon | 11 153 | -6,2 % | 3,6 %
6 | 9 | Qualcomm (3) | Drapeau des États-Unis États-Unis | 10 080 | +39,9 % | 3,2 %
7 | 7 | STMicroelectronics | Drapeau de la France France Drapeau de l'Italie Italie | 9 792 | -5,4 % | 3,1 %
8 | 6 | Hynix | Drapeau de la Corée du Sud Corée du Sud | 8 911 | -14,2 % | 2,8 %
9 | 8 | Micron Technology | Drapeau des États-Unis États-Unis | 7 344 | -17,3 % | 2,3 %
10 | 10 | Broadcom | Drapeau des États-Unis États-Unis | 7 153 | +7,0 % | 2,3 %
11 | 12 | Advanced Micro Devices | Drapeau des États-Unis États-Unis | 6 483 | +2,2 % | 2,1 %
12 | 13 | Infineon Technologies | Drapeau de l'Allemagne Allemagne | 5 403 | -14,5 % | 1,7 %
13 | 14 | Sony | Drapeau du Japon Japon | 5 153 | -1,4 % | 1,6 %
14 | 16 | Freescale Semiconductor | Drapeau des États-Unis États-Unis | 4 465 | +2,5 % | 1,4 %
15 | 11 | Elpida Memory | Drapeau du Japon Japon | 3 854 | -40,2 % | 1,2 %
16 | 17 | NXP | Drapeau des Pays-Bas Pays-Bas | 3 838 | -4,7 % | 1,2 %
17 | 20 | NVIDIA | Drapeau des États-Unis États-Unis | 3 672 | +14,9 % | 1,2 %
18 | 18 | Marvell Technology Group | Drapeau des États-Unis États-Unis | 3 448 | -4,4 % | 1,1 %
19 | 26 | ON Semiconductor (4) | Drapeau des États-Unis États-Unis | 3 423 | +49,4 % | 1,1 %
20 | 15 | Panasonic Corporation | Drapeau du Japon Japon | 3 365 | -32,0 % | 1,1 %
Top 20 |  |  |  | 203 907 | 3,5 % | 65,2 %
Toutes les autres entreprises |  |  |  | 108 882 | -1,1 % | 34,8 %
TOTAL |  |  |  | 312 789 | 1,9 % | 100,0 %

Source : IHS iSuppli 2011 [archive]

Notes :

  • (1) Intel Corporation acquisition de la division sans fil deInfineon Technologies.

  • (2) Texas Instruments acquisition de National Semiconductor.

  • (3) Qualcomm acquisition de Atheros Communications.

  • (4) ON Semiconductor acquisition de Sanyo semiconductor division.

Les principales entreprises de production de circuits intégrés présentes en France sont :

  • Altis Semiconductor (Corbeil-Essonnes)

  • Atmel (Saint-Quentin-en-Yvelines, Saint-Egrève)

  • Freescale (Toulouse, Paris)

  • Ipdia (Caen)

  • LFoundry (Rousset, ex Atmel)

  • MHS Electronics (Nantes, ex Atmel) [1] [archive]

  • NXP (Rennes, Sophia-Antipolis, Le Mans)

  • ON Semiconductor (Toulouse)

  • STMicroelectronics (Grenoble, Crolles, Tours, Rousset, Rennes, Paris)

  • Soitec (Bernin) Soitec n'est pas à proprement parler une entreprise de composants, elle produit le substrat en SOI qui permet la fabrication de certains de ces composants.

Écologie

Il faut une quantité considérable de matière première pour fabriquer une puce électronique : le sac à dos écologique (qui représente la quantité de matières premières nécessaires à la fabrication du produit) d'une puce électronique de 0,09 g est de 20 kg[5].

Notes et références

  1. ↑ Jack Kilby [archive]

  2. ↑ http://www.iutbayonne.univ-pau.fr/~dalmau/documents/cours/archi/MICROPancien.pdf [archive]

  3. ↑ Bulletin de la Societe fribourgeoise des sciences naturelles, Volumes 62 à 63, 1973 (lire en ligne [archive])

  4. ↑ http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=1484037&url=http%3A%2F%2Fieeexplore.ieee.org%2Fstamp%2Fstamp.jsp%3Ftp%3D%26arnumber%3D1484037 [archive]

  5. ↑ Marine Fabre et Wiebke Winkler, Les Amis de la Terre / CNIID, « L'obsolescence programmée, symbole de la société du gaspillage, le cas des produits électriques et électroniques », Rapport • Septembre 2010 [archive], qui citent Wuppertal Institut für Klima, Umwelt, Energie Gmbh : « Infobrief Forschungsgruppe nachhaltiges Produzieren und Konsumieren », 2008, p. 4

Voir aussi

Sur les autres projets Wikimedia :

  • les circuits intégrés, sur Wikimedia Commons

Articles connexes

  • Circuit imprimé

  • Circuit intégré monolithique hyperfréquence

  • Microprocesseur

  • Microcontrôleur

  • Fabricant de composant électronique

  • Puce sous-cutanée

  • Analyse temporelle statique


Bit — Wikipédia

Bit

Un article de Wikipédia, l'encyclopédie libre.

Le bit est l'unité la plus simple dans un système de numération, ne pouvant prendre que deux valeurs, désignées le plus souvent par les chiffres 0 et 1. Un bit ou élément binaire peut représenter aussi bien une alternative logique, exprimée par faux et vrai, qu'un chiffre du système binaire.

Dans la théorie de l'information, un bit est la quantité minimale d'information transmise par un message, et constitue à ce titre l'unité de mesure de base de l'information en informatique. La quantité d'information effectivement transmise s'exprime en shannons, et ne peut dépasser la taille du message en bits.

Les systèmes numériques traitent exclusivement des informations réduites en bits, en général associés dans des groupes de taille fixe appelés bytes (/bait/).

Sommaire

1 Usages

    • 1.1 Élément binaire

    • 1.2 Unité d'information

  • 2 Ensembles ordonnés de bits

  • 3 Abréviation et symbole

  • 4 Voir aussi

    • 4.1 Articles connexes

    • 4.2 Notes et références

Usages

Le mot « bit » est la contraction des mots anglais binary digit, qui signifient « chiffre binaire », avec un jeu de mot sur bit, « petit morceau ». On en doit la popularisation à Claude Shannon, qui en attribue l'invention à John Tukey [1].

Élément binaire

Le bit ou élément binaire est l'élément constitutif du système de numération binaire[2]. Ce système, le plus analytique de tous les systèmes de numération, est à la base de presque tous les systèmes informatiques [3].

Notations des valeurs

Contexte | Valeurs
Logique | faux | vrai
 |  | non | oui
Numérique | 0 | 1

Un bit ne peut prendre que deux valeurs. En logique (algèbre de Boole), ces valeurs sont vrai et faux, ou quelquefois oui et non. En arithmétique, ce sont 0 et 1.

De nombreux moyens techniques permettent de coder une information binaire. La polarisation magnétique, la charge électrique servent au stockage, le courant ou la tension électriques, l'intensité lumineuse sont couramment utilisés pour la transmission. L'essentiel est de distinguer avec une très bonne fiabilité les deux états de manière à limiter les erreurs. La correspondance entre chacun des deux états et une valeur du bit correspondant est affaire de convention. Un Interrupteur peut être soit ouvert, soit fermé pour coder 0 ou 1 ; l'autre état code l'autre valeur. Il en va de même pour la tension ou le courant électriques, la polarisation magnétique, la lumière allumée ou éteinte.

Unité d'information

Article détaillé : Entropie de Shannon.

Selon la théorie mathématique de l'information de Shannon, lorsque l'on reçoit l'information correspondant à l'occurrence d'un évènement ayant 1 chance sur 2 de se produire, on reçoit un bit d'information.

Exemple - Pile ou face :

Lors du tir à pile ou face de l'engagement d'un match de football, quand l'arbitre indique que la pièce est tombée sur pile, il transmet un bit d'information aux 2 capitaines des équipes en compétition, parce qu'avant cette annonce, la probabilité d'obtenir l'un ou l'autre résultat était égale.

Le nom de l'unité élémentaire d'information est le shannon , symbole Sh[4].

Dans un encodage idéal de l'information, tout bit (élément binaire) porterait un shannon d'information. Ce n'est pas le cas, parce que les informations environnant un bit dans un flux peuvent affecter sa probabilité d'avoir l'une ou l'autre valeur. L'information contenue dans un flux de n bits est au maximum de n shannons. Elle est en général moindre, parce que toutes les combinaisons ne correspondent pas à des messages valides de probabilité égale.

Exemple - bit de parité :

Pour assurer une détection d'erreur, on transmet volontairement des informations excédentaires, qui se déduisent des données transmises. Un des systèmes les plus simples consiste à coder sur 8 bits un mot de 7 bits, le huitième, appelé bit de parité, étant calculé de telle sorte que le nombre total de 1 dans l'ensemble soit toujours soit pair, soit impair, selon la convention en vigueur.

Un tel ensemble de 8 octets n'a que 27 valeurs possibles, et transporte 7 et non 8 shannons.

Outre ces redondances volontaires, introduites dans le but de corriger les erreurs de transmission, les encodages contiennent une part de répétition que l'on conserve parce qu'elles facilitent le traitement des données numériques.

Exemple - Nombre en virgule flottante :

En informatique, on code souvent les grandeurs en nombres à virgule flottante. La norme IEEE 754 fixe, pour le codage sur 32 bits, un encodage qui détermine 4 286 578 689 valeurs valides sur les 232, soit 4 294 967 296 possibles.

Un nombre en virgule flottante de 32 bits apporte ainsi 31,997 et non 32 shannons d'information.

En outre, les communications humaines contiennent une part involontaire de répétition, qui peut être partiellement réduite par l'analyse statistique. La compression de données vise à rapprocher le nombre de bits d'un message de la quantité d'information qu'il transmet, élevant ainsi le nombre de shannons par bit.

Lorsqu'on ne se préoccupe pas de l'efficacité de l'encodage, un bit et un shannon sont pratiquement équivalents.

Si on souhaite renoncer à cette correspondance éventuellement trompeuse entre l'unité de codage et celle d'information, on peut exprimer la quantité d'information en nats, basés sur le logarithme naturel et non comme le bit sur le logarithme en base 2. Un nat est égal à un shannon multiplié par le logarithme naturel de 2, soit environ 0,7.

Ensembles ordonnés de bits

Il ne faut pas confondre un bit avec un byte, mot anglais qui se prononce /bait/ et se traduit par multiplet [5], ensemble ordonné de bits. En informatique, le byte est généralement un ensemble ordonné de 8 bits, ce qui dans ce cas fait un octet. Quand le nombre d'éléments binaires qui le compose est différent, cela est normalement précisé. On peut ainsi trouver les formes « doublet », « triplet », et plus généralement, « n-uplet »[6].

Abréviation et symbole

Unités de bits

Ordre de grandeur | Système international (SI) |  |  | Préfixes binaires
 | Unité | Notation | Valeur | Unité | Notation | Valeur
1 | bit | bit | 1 bit | bit | bit | 1 bit
103 | kilobit | kbit | 103 bits | kibibit | Kibit | 210 bits
106 | mégabit | Mbit | 106 bits | mébibit | Mibit | 220 bits
109 | gigabit | Gbit | 109 bits | gibibit | Gibit | 230 bits
1012 | térabit | Tbit | 1012 bits | tébibit | Tibit | 240 bits
1015 | pétabit | Pbit | 1015 bits | pébibit | Pibit | 250 bits
1018 | exabit | Ebit | 1018 bits | exbibit | Eibit | 260 bits
1021 | zettabit | Zbit | 1021 bits | zébibit | Zibit | 270 bits
1024 | yottabit | Ybit | 1024 bits | yobibit | Yibit | 280 bits

Il n'y a pas de norme universellement acceptée au sujet des abréviations de bit et byte.

bit
La Commission électrotechnique internationale définit dans l'IEC 60027 (en) bit comme étant le symbole de l'unité binaire (par exemple, kbit pour kilobit). Le standard harmonisé ISO/IEC IEC 80000-13:2008 (en) annule et remplace les articles 3.8 et 3.9 de la norme IEC 60027-2:2005 (relatifs à la théorie de l'information et aux préfixes binaires).
b
L'IEEE donne dans IEEE 1541 (en) b comme symbole d'unité pour bit. Cette convention est fréquemment utilisée en informatique, mais le Système international d'unités, dont le bit ne fait pas partie, utilise b est déjà utilisé pour une autre unité, le barn, dans un domaine spécialisé différent[7]. D'autre part, bit est déjà l'abréviation de binary digit il y a peu de raison de l'abréger encore.
B
Les textes cités de la CIE et de l'IEEE donnent B comme abréviation pour le byte . La CIE, comme l'Union internationale des télécommunications acceptent o pour octet au lieu de byte. Le terme octet est plus précis, ne dépend pas d'une base matérielle, et est plus courant dans les pays francophones.
Dans le Système international d'unités, le symbole d'une unité s'écrit en minuscules sauf si son nom provient de celui d'une personne ont un symbole abrégé en majuscule[8].
Hors Système international d'unités, B désigne le bel ; mais on n'utilise que son sous-multiple le décibel (dB), qu'il est peu probable de confondre avec un décibyte, puisqu'on n'emploie que des multiples du byte en télécommunications et en informatique.

Voir aussi

Articles connexes

  • Débit binaire

  • Préfixe binaire

  • Système binaire

  • Octet

  • Byte

  • Algèbre de Boole (logique)

Notes et références

  1. ↑ Trésor de la langue française informatisé [archive] ; Oxford English Dictionnary, « bit (4) » ; (en) Claude E. Shannon, « A Mathematical Theory of Communication », Bell System Technical Journal, vol. 27,‎ juillet et octobre 1948, p. 379-423 et 623-656 (ISBN 0252725484, lire en ligne [archive]).

  2. ↑ Commission électrotechnique internationale, Electropedia 721-02-08 « bit » [archive] ; Trésor de la langue française informatisé [archive].

  3. ↑ Sauf les calculateurs quantiques : « bit », dans Richard Taillet, Loïc Villain et Pascal Febvre, Dictionnaire de physique, Bruxelles, De Boeck, 2013, p. 73.

  4. ↑ France Terme [archive], citant le Journal officiel de la république française du 14 décembre 2004 ; Electropedia 702-04-21 [archive] ; Union internationale des télécommunications, Recommandation UIT-R V.607-2 [archive].

  5. ↑ Dictionnaire anglais-français/français-anglais Harrap's Compact

  6. ↑ Commission électrotechnique internationale, Electropedia 721-02-18 « octet » [archive], 721-05-06 « multiplet » [archive], 704-16-20 « multiplet, n-uplet ». [archive]

  7. ↑ Bureau international des poids et mesures, brochure sur le Système international d'unités [archive].

  8. ↑ Le symbole L pour le litre est cepedant accepté [archive].


Bascule de Schmitt — Wikipédia

Bascule de Schmitt

Un article de Wikipédia, l'encyclopédie libre.

image illustrant l’électronique

Une bascule de Schmitt, aussi appelée trigger de Schmitt ou bascule à seuil, est un circuit logique inventé en 1934 par Otto Schmitt, ingénieur américain.

Symbole

Sommaire

1 Principe

  • 2 Fonctionnement

  • 3 Applications

  • 4 Utilisation en électronique numérique

  • 5 Références

Principe

C'est une bascule à trois entrées V, SB et SH et une sortie Q. Contrairement aux autres bascules, qui sont commandées en appliquant des signaux logiques à leurs entrées, la bascule de Schmitt est conçue pour être pilotée par une tension analogique, c'est-à-dire qui peut prendre n'importe quelle valeur (dans l'intervalle 0 - Vcc afin de ne pas dégrader le circuit).

Les entrées SB et SH (seuil bas, seuil haut, ce dernier étant à un potentiel supérieur à SB) sont maintenues à des potentiels fixes ; ceci peut se faire par exemple grâce à un diviseur de tension composé de 3 résistances placées en série entre Vcc et la masse ; SH et SB sont reliés aux points intermédiaires du diviseur.

Fonctionnement

Chronogramme

Le fonctionnement est le suivant :

  • supposons qu'au départ, V soit à 0 ; Q est alors à 0 ;

  • quand V augmente, Q reste à 0 jusqu'à ce que V dépasse SH ; à ce moment, Q passe à 1 ;

  • Q reste à 1 jusqu'au moment où V devient inférieur à SB ; à ce moment, Q passe à 0;

  • Q reste à 0 jusqu'à ce que V repasse au-dessus de SH.

Applications

La principale application de la bascule de Schmitt est la mise en forme de signaux analogiques pour les appliquer à des circuits logiques (par exemple une entrée de compteur). Cette utilisation est qualifiée quelques fois de circuit « conformateur »[1].

La bascule de Schmitt peut aussi être utilisée pour :

  • débarrasser un signal du bruit ; il suffit que l'écart entre SH et SB soit supérieur à l'amplitude crête-à-crête du signal ;

  • réaliser des circuits de contrôle avec hystérésis : thermostats, interrupteurs crépusculaires, maintien du niveau dans une cuve...

  • le trigger de Schmitt est l'ancêtre des générateurs de musique et a été très longtemps utilisé pour les appareils électroniques devant générer du son, comme les montres électroniques, les sonneries des téléphones portables, les Game-Boy et consoles de jeux antérieures à la génération 16-bit, les alarmes électroniques, les cartes de vœux parlantes, les boîtes à musique et horloges électroniques, etc. Il ne pouvait générer que des signaux rectangulaires, appelés dans le langage courant "sons électroniques", et ont été très longtemps associés aux jeux vidéo même après que la bascule de Schmitt soit tombée en désuétude pour ce type d'application. Le fameux bip des premiers ordinateurs dans les années 1980 était un signal rectangulaire.

Utilisation en électronique numérique

Symbole d'une porte Trigger de schmitt [2] : Symbole

Le dessin contenu dans le triangle représente le cycle d'hystérésis caractéristique de ces portes logiques : Cycle d'hystérésis

Ces portes permettent de s'assurer de la stabilité d'un signal de sortie logique en fonction d'un signal d'entrée analogique.

Références

  1. ↑ R. Bourgeron, Guide Pratique de l'électronique, Hachette, coll. « Hachette technique », 1998, 207 p. (ISBN 9782011805218), p. 140


Bascule (circuit logique) — Wikipédia

Bascule (circuit logique)

Un article de Wikipédia, l'encyclopédie libre.

Une bascule est un circuit logique capable, dans certaines circonstances, de maintenir les valeurs de ses sorties malgré les changements de valeurs d'entrées, c'est-à-dire comportant un état « mémoire ». Il s'agit de l'élément qui permet le passage de la logique combinatoire à la logique séquentielle.

On distingue deux catégories principales de bascules : les bascules asynchrones, que l'on nomme verrous (en anglais latch) et les bascules synchrones que l'on nomme simplement bascules (en anglais flip-flop).

Sommaire

1 Description

    • 1.1 Bascules asynchrones, ou verrous

    • 1.2 Bascules synchrones

  • 2 Métastabilité

  • 3 Types de bascules et de verrous

    • 3.1 Verrou RS avec porte NON-OU

    • 3.2 Verrou non R non S avec porte NON-ET

    • 3.3 Verrou D

    • 3.4 Verrou RSH - RST

    • 3.5 Bascule JK

      • 3.5.1 Origine du nom de la bascule JK

    • 3.6 Bascule D

    • 3.7 Bascule T

    • 3.8 Bascule de Schmitt

  • 4 Notes et références

  • 5 Voir aussi

Description

Une bascule ou un verrou est un circuit logique doté d'une ou plusieurs entrées et d'une ou deux sorties. Les changements d'état de la sortie sont déterminés par les signaux appliqués aux entrées et le type d'opérateur implémenté.

Ce qui différencie les bascules des circuits logiques combinatoires (portes ET, OU, OU Exclusif, etc.), c'est que la sortie maintient son état même après disparition du signal de commande. Comme l'état précédent intervient dans le calcul de la valeur de sortie via la mémorisation, on parle de logique séquentielle.

La bascule est l'élément de base de la logique séquentielle. En effet, en assemblant des bascules, on peut réaliser des compteurs, des registres, des registres à décalage, ou encore des mémoires.

Il existe deux types de bascules : les bascules synchrones, possédant une entrée d'horloge de synchronisation, et les bascules asynchrones, ou verrous.

Bascules asynchrones, ou verrous

Les verrous (désignés en anglais par le terme latch ou latched) sont des bascules dont la sortie dépend uniquement du niveau logique des entrées. Son évolution ne dépend donc que de la succession des combinaisons appliquées, et n'est limitée que par la vitesse de commutation de la bascule et de ses entrées. Si les entrées ont des oscillations imprévisibles avant de se stabiliser, ces valeurs transitoires pourront donc se répercuter sur la sortie d'une bascule asynchrone. La porte C de Muller est un exemple de bascule asynchrone.

Bascules synchrones

Ici, l'action des entrées sur l'état de mémorisation ne sera effective qu'à la réception d'un front d'horloge, lorsqu'elle passe de l'état bas à l'état haut (front montant), ou inversement (front descendant). Certaines bascules ne réagissent que sur un seul type de front, d'autres à chaque changement d'état de l'horloge. La sortie est dite synchrone (à l'horloge H) car seul un évènement sur l'horloge peut faire évoluer sa sortie. Contrairement à une bascule asynchrone, la sortie d'une bascule synchrone ne sera pas affectée par des valeurs transitoires sur ses entrées, pouvant changer plusieurs fois de valeur au cours d'un cycle en fonction des temps de propagation des circuits placés en amont. Les changements d'état de l'horloge doivent simplement être suffisamment lents pour que les entrées aient eu le temps d'atteindre leur configuration finale.

Ces bascules peuvent disposer d'entrées asynchrones (Set, Reset) pour prépositionner l'état de sortie à la mise sous tension.

Métastabilité

Les bascules peuvent entrer dans des états métastables lorsque plusieurs entrées changent simultanément, c'est-à-dire qu'elles peuvent n'offrir une sortie stable qu'au bout d'un temps arbitrairement long. Ce peut être le cas pour le verrou RS si les deux entrées passent ensemble de 1 à 0, ou pour une bascule où un changement de donnée d'entrée est trop proche d'un front d'horloge. On cherche à les éviter, mais ce n'est pas toujours possible, par exemple pour des éléments arbitrant entre deux signaux asynchrones.

Types de bascules et de verrous

Verrous et bascules sont en fait très proches. Dans le cas de verrous, il est possible de réaliser une bascule synchrone en ajoutant une entrée d'horloge, la sortie ne pouvant changer qu'après un front de l'horloge. On ne citera pas alors la bascule ainsi créée, d'implémentation plus complexe.

Les entrées sont séparées en entrées de contrôle et de données, bien que ces dernières ne soient pas forcément présentes selon le type de bascule. On retrouvera dans chaque type de bascule un état mémoire, généralement noté q ou Qn-1 pour les bascules synchrones, représentant l'état de la sortie avant le dernier basculement des entrées. La sortie est généralement notée Q, et on trouve parfois une sortie non Q représentant le complément de la sortie. Néanmoins, dans certaines conditions, on trouve des combinaisons d'entrée interdites pouvant mener à des valeurs de Q et non Q en contradiction avec cette règle[1].

Verrou RS avec porte NON-OU

R1, R2 = 1 kΩ R3, R4 = 47 kΩ.

Symbole du verrou RS.

L'implémentation utilisant des portes NON-OU.

Un verrou RS possède deux entrées de contrôle : Set et Reset, et n'a pas d'entrée de donnée. Les deux signaux de sortie Q et non Q sont présents. Le fonctionnement de cette bascule est le suivant :

  • Mise à 1 de S (Set) : la sortie Q passe à 1.

  • Mise à 1 de R (Reset) : la sortie Q passe à 0.

  • R = S = 0 : état mémoire : la sortie Q maintient sa valeur précédente q.

Table de vérité

S | R | Q | non Q | remarque
0 | 0 | q | non q | mémoire
0 | 1 | 0 | 1 | mise à 0
1 | 0 | 1 | 0 | mise à 1
1 | 1 | 0 | 0 | état interdit

Verrou non R non S avec porte NON-ET

L'implémentation utilisant des portes NON-ET.

Un verrou non R non S a un fonctionnement opposé au verrou RS. On retrouve les entrées Set et Reset, mais leur comportement est inversé. Les sorties sont les mêmes. Son fonctionnement est le suivant :

  • Mise à 0 de non S (Set) : la sortie Q passe à 1.

  • Mise à 0 de non R (Reset) : la sortie Q passe à 0.

  • non R = non S = 1 : la sortie Q maintient sa valeur précédente q.

Table de vérité

non S | non R | Q | non Q | remarque
0 | 0 | 1 | 1 | état interdit
0 | 1 | 1 | 0 | mise à 1
1 | 0 | 0 | 1 | mise à 0
1 | 1 | q | non q | mémoire

Verrou D

Un verrou D possède une entrée de contrôle, notée H, et une entrée de données, notée D. On retrouve les deux signaux de sortie Q et non Q. Le fonctionnement de cette bascule est le suivant :

  • quand H est à 0, la sortie maintient son état, quel que soit le niveau appliqué à D.

  • quand H est à 1, la sortie Q recopie l'état de D.

Dans la table de vérité, on note X est un état quelconque, c'est-à-dire dont la valeur est ignorée pour le calcul du résultat.

Table de vérité (optimisée)

D | H | Q | non Q | remarque
d | 1 | D | non D | Q recopie D
X | 0 | q | non q | mémoire

Verrou RSH - RST

Un verrou RSH (aussi appelé RST) est un verrou RS auquel on a ajouté une troisième entrée, généralement notée H (ou CLK pour horloge). Cette troisième entrée a la fonction suivante :

  • si H est au niveau logique 0, la sortie maintient son état, quels que soient les niveaux appliqués aux entrées R et S ;

  • si H est à 1, la bascule RS répond normalement aux commandes appliquées à ses entrées.

Dans les documentations techniques en anglais, ce verrou est généralement appelé gated SR latch et cette troisième entrée est plutôt notée E ou EN (Enable) ou en logique inversée, H (Hold) : lorsqu'il est à zéro, le verrou ignore l'état des autres entrées (R et S) et maintient l'état de sortie.

Table de vérité

H | S | R | Q | non Q | remarque
0 | X | X | q | non q | mémoire
1 | 0 | 0 | q | non q | mémoire
1 | 0 | 1 | 0 | 1 | mise à 0
1 | 1 | 0 | 1 | 0 | mise à 1
1 | 1 | 1 | 0 | 0 | état interdit

Équation du verrou : Q n = S + R ¯ Q n − 1 {\displaystyle Q_{n}=S+{\overline {R}}Q_{n-1}}

Bascule JK

Symbole de la bascule JK à front montant.

En chainant 2 verrous RSH (un maître, l'autre esclave), on réalise une bascule JK (maître-esclave). Cette bascule comporte deux entrées de contrôle : J (Jack) et K (King). S'agissant d'une bascule, le fonctionnement est synchrone à une entrée d'horloge H, c'est-à-dire que la valeur de sortie ne peut changer qu'au moment d'un front d'horloge, montant ou descendant selon les modèles.

  • Pour J = K = 0, il y a conservation du dernier état logique Qn-1 indépendamment de l'horloge : état mémoire.

  • Pour J = K = 1, le système bascule à chaque front d'horloge.

  • Pour J différent de K, la sortie Q recopie l'entrée J et la sortie non Q recopie l'entrée K à chaque front d'horloge.

Table de vérité

J | K | Qn
0 | 0 | Qn-1
0 | 1 | 0
1 | 0 | 1
1 | 1 | non Qn-1

Table de vérité alternative

Qn-1 | J | K | Qn | remarque
0 | 0 | X | 0 | pour que la sortie reste à 0, il faut que J soit à 0, peu importe K.
0 | 1 | X | 1 | pour que la sortie passe de 0 à 1, il faut que J soit à 1, peu importe K.
1 | X | 1 | 0 | pour que la sortie passe de 1 à 0, il faut que K soit à 1, peu importe J.
1 | X | 0 | 1 | pour que la sortie reste à 1, il faut que K soit à 0, peu importe J.

On peut utiliser cette bascule pour faire des compteurs. On compte jusqu'à 2n avec n bascules à la suite et on compte dans l'ordre croissant avec des bascules à front descendant et dans l'ordre décroissant avec des bascules à front montant.

Équation de la bascule : Q n = J Q ¯ n − 1 + K ¯ Q n − 1 {\displaystyle Q_{n}=J{\overline {Q}}_{n-1}+{\overline {K}}Q_{n-1}}

Chronogramme.

Origine du nom de la bascule JK

L'origine du nom de la bascule JK est détaillée par P. L. Lindley, un ingénieur de JPL, dans un article du magazine de conception électronique EDN . L'article est daté du 13 juin 1968 et a été publié dans l'édition d'Août. Dans cet article, M. Lindley explique que c'est le docteur Eldred Nelson, un scientifique de Hughes Aircraft qui a inventé le terme de bascule JK.

Les bascules qui étaient utilisées à cette époque à Hughes étaient toutes du même type, celui de la future bascule J-K. Durant la conception d'un système logique le docteur Nelson a assigné des lettres à chaque entrée des bascules de la façon suivante :

  • bascule 1, les lettres A et B,

  • bascule 2, les lettres C et D,
    …

  • bascule 5, les lettres J et K,
    …

Étant donné la taille du système sur lequel travaillait le docteur Nelson, il s'est rendu compte qu'il allait être à court de lettres. Puisque les lettres J et K étaient peu utilisées dans les systèmes électroniques il a donc décidé d'utiliser ces lettres comme entrées "Set" et "Reset" pour toutes les bascules de son système (avec des indices pour les distinguer les unes des autres).

Le docteur Montgomery Phister, un membre de l'équipe du docteur Nelson à Hughes, a repris dans son livre Logical Design of Digital Computers (Wiley, 1958) l'idée que les entrées "Set" et "Reset" des bascules utilisées à Hughes Aircraft étaient nommées J et K. De ce fait il est alors amené à les désigner sous le terme de bascule JK. Dans ce même livre il a aussi défini les bascules R-S, T, D et R-S-T et a montré qu'en utilisant l'algèbre de Boole il était possible de les combiner afin de réaliser des fonctions complexes.

Bascule D

Symbole de la bascule D.

La bascule D (pour Data) est une bascule comportant uniquement une entrée de données : D. La valeur de l'entrée est recopiée sur la sortie à chaque front d'horloge. Cette bascule permet d'assurer un état de sortie stable entre deux fronts d'horloge, et ainsi d'ignorer toute valeur transitoire apparaissant sur son entrée au cours d'un cycle d'horloge. On ajoute parfois un signal reset afin de pouvoir forcer la valeur initiale à la mise sous tension. Il existe des versions où les changements d'état ont lieu au moment des fronts descendants de l'horloge. Elles se signalent par une barre supplémentaire (en dessous à 45°) sous l'entrée H.

Table de vérité

D | H | Qn | non Qn
0 | ↗ {\displaystyle \nearrow } | 0 | 1
1 | ↗ {\displaystyle \nearrow } | 1 | 0
X | 0 | Qn-1 | non Qn-1
X | 1 | Qn-1 | non Qn-1

Table de vérité (optimisée)

D | H | Qn | non Q | remarque
d | ↗ {\displaystyle \nearrow } | d | non d | Q recopie D
X | 1,0,front descendant | Qn-1 | non Qn-1 | mémorisation

On peut faire l'analogie avec la bascule JK en considérant que l'on a relié les deux entrées ensemble via un inverseur. Il y a donc une seule entrée. La table de vérité sera alors la table de vérité d'une JK, limitée aux deux lignes J = 0, K = 1 et J = 1, K = 0.

Équation de la bascule : Q n = D n − 1 {\displaystyle Q_{n}=D_{n-1}}

Bascule T

La bascule T tire son nom du terme anglais 'toggle'. Si son entrée T est active, elle bascule à chaque impulsion d'horloge d'où son nom. Si son entrée T est inactive, elle conserve son état.

Elle n'existe pas intégrée sauf dans des PLD, FPGA… mais on peut la fabriquer avec une bascule D en reliant la sortie non Q à l'entrée D (toutefois on ne réalise ainsi qu'une bascule T avec T=1), ou à l'aide d'une bascule JK en reliant J et K pour faire l'entrée T.

Comme la bascule T a la propriété de basculer à chaque impulsion d'horloge, elle réalise donc une division de fréquence par 2 ; elle servira aussi de base à la réalisation de compteurs (association simple si actives au front descendant de l'horloge). Intégrée dans un circuit, elle est souvent active sur un front descendant.

  • si T=1, on bascule à chaque impulsion d'horloge.

  • si T=0, la sortie ne change pas : état mémoire.

Table de vérité (optimisée)

T | H | Qn | non Qn | remarque
1 | ↗ {\displaystyle \nearrow } | non Qn-1 | Qn-1 | basculement
1 | 0,1, ↘ {\displaystyle \searrow } | Qn-1 | non Qn-1 | mémorisation
0 | 0,1, ↗ {\displaystyle \nearrow } [image] , ↘ {\displaystyle \searrow } | Qn-1 | non Qn-1 | mémorisation

Bascule de Schmitt

Article détaillé : Bascule de Schmitt.

On l'appelle aussi Trigger de Schmitt ou bascule à seuil.

Symbole.

C'est une bascule à trois entrées V, SB et SH et une sortie Q. Contrairement aux bascules citées ci-dessus, qui sont commandées en appliquant des signaux logiques à leurs entrées, la bascule de Schmitt est conçue pour être pilotée par une tension analogique, c'est-à-dire qui peut prendre n'importe quelle valeur (dans l'intervalle 0 - Vcc afin de ne pas dégrader le circuit).

Les entrées SB et SH (seuil bas, seuil haut, ce dernier étant à un potentiel supérieur à SB) sont maintenues à des potentiels fixes ; ceci peut se faire par exemple grâce à un diviseur de tension composé de 3 résistances placées en série entre Vcc et la masse ; SH et SB sont reliés aux points intermédiaires du diviseur.

Chronogramme.

Le fonctionnement est le suivant :

  • supposons qu'au départ, V soit à 0 ; Q est alors à 0 ;

  • quand V augmente, Q reste à 0 jusqu'à ce que V dépasse SH ; à ce moment, Q passe à 1 ;

  • Q reste à 1 jusqu'au moment où V devient inférieur à SB ; à ce moment, Q passe à 0 ;

  • Q reste à 0 jusqu'à ce que V repasse au-dessus de SH.

La principale application de la bascule de Schmitt est la mise en forme de signaux analogiques pour les appliquer à des circuits logiques (par exemple une entrée de compteur).

La bascule de Schmitt peut aussi être utilisée pour :

  • débarrasser un signal du bruit ; il suffit que l'écart entre SH et SB soit supérieur à l'amplitude crête-à-crête du bruit ;

  • réaliser des circuits de contrôle avec hystérésis : thermostats, interrupteurs crépusculaires, maintien du niveau dans une cuve...

  • le trigger de Schmitt est l'ancêtre des générateurs de musique, miniaturisé dans les sonneries des montres électroniques, les sonneries des téléphones portables, les Game-Boy et autres jeux électroniques, les alarmes électroniques, les cartes de vœux parlantes, les boîtes à musique et horloges électroniques, etc. Le fameux bip des premiers ordinateurs dans les années 1980 était un signal rectangulaire.

Notes et références

  1. ↑ Notamment pour des raisons internes à l'intégration des bascules/verrous dans des circuits intégrés optimaux, Q et non Q peuvent être dissociés sans que cela n’ait d'influence sur le mode de fonctionnement normal.

Voir aussi

  • Mémoire vive statique

Sur les autres projets Wikimedia :

  • Bascules électroniques, sur Wikiversity


Additionneur — Wikipédia

Additionneur

Un article de Wikipédia, l'encyclopédie libre.

Un additionneur est un circuit logique permettant de réaliser une addition. Ce circuit est très présent dans les ordinateurs pour le calcul arithmétique mais également pour le calcul d'adresses, d'indice de tableau dans le processeur.

On dénombre deux types d'additionneurs : parallèle (circuit combinatoire) et série (circuit séquentiel). Dans la classe des additionneurs parallèles, nous décrirons ici ceux à propagation de retenue et ceux à retenue anticipée.

Sommaire

1 Additionneur parallèle

    • 1.1 Demi-additionneur

    • 1.2 Additionneur complet

    • 1.3 Additionneur parallèle à propagation de retenue

    • 1.4 Additionneur parallèle à retenue anticipée

  • 2 Additionneur série

  • 3 Optimisation des additionneurs

  • 4 Notes et références

  • 5 Voir aussi

    • 5.1 Liens internes

    • 5.2 Liens externes

Additionneur parallèle

Codée sur un bit, la table de vérité de l'addition est :

A | B | A + B | Retenue
0 | 0 | 0 | 0
0 | 1 | 1 | 0
1 | 0 | 1 | 0
1 | 1 | 0 | 1

Remarquons dans le tableau ci-dessus que A+B représente le poids faible tandis que Retenue représente le poids fort.

Demi-additionneur

À partir de cette table de vérité on peut par exemple construire le circuit suivant, appelé « demi-additionneur » :

Demi-additionneur (1 bit) où A et B sont les entrées, S la somme A + B et C la retenue.

Additionneur complet

Un additionneur complet nécessite une entrée supplémentaire : une retenue. L'intérêt de celle-ci est de permettre le chaînage des circuits. La table de vérité d'un additionneur complet est :

A | B | REntrée | S | RSortie
0 | 0 | 0 | 0 | 0
0 | 0 | 1 | 1 | 0
0 | 1 | 0 | 1 | 0
0 | 1 | 1 | 0 | 1
1 | 0 | 0 | 1 | 0
1 | 0 | 1 | 0 | 1
1 | 1 | 0 | 0 | 1
1 | 1 | 1 | 1 | 1

Le circuit correspondant à l'additionneur complet, est composé de deux demi-additionneurs en série accompagnés d'une logique pour calculer la retenue (un OU entre les deux retenues générables par chacun des demi-additionneurs) :

Un additionneur complet 1 bit.

Additionneur parallèle à propagation de retenue

Il est possible de chaîner plusieurs additionneurs un bit pour en fabriquer un capable de traiter des mots de longueurs arbitraires :

Quatre additionneurs 1 bit chaînés pour former un additionneur 4 bits.

L'inconvénient de ce circuit est sa lenteur car il dépend du temps de propagation de la retenue de module en module. Cette conception ne peut être choisie pour des circuits dépassant quelques bits, à moins de n'avoir aucune contrainte de temps : le temps nécessaire pour calculer le résultat augmente linéairement avec la taille des entrées.

Additionneur parallèle à retenue anticipée

Dans ce qui suit on note A et B le cumulande et le cumulateur. R est la retenue. Xindice indique le bit auquel on s'intéresse, 0 étant l'indice de poids le plus faible. La fonction logique OU est notée « + ». La fonction logique ET est notée « . » ou n'est pas notée du tout (ainsi A B est l'équivalent de A . B ou A ET B).

Tout d'abord on constate que le calcul de la retenue est tout à fait faisable théoriquement : dans la pratique il nécessite beaucoup trop de portes logiques. Pour le second additionneur, la retenue (en entrée) est égale à : R1 = (A0 . B0) + (A0 . R0) + (B0 . R0) (1)

Pour le troisième additionneur, la retenue est égale à : R2 = (A1 . B1) + (A1 . R1) + (B1 . R1) (2) et ainsi de suite. On peut substituer R1 dans (2) par sa valeur (1). On voit immédiatement que le résultat est une formule très longue rendant cette technique totalement impraticable pour un additionneur de, par exemple, 16 bits.

Additionneur 1 bit avec les sorties p et g complémentaires

Il faut donc trouver un compromis entre vitesse et complexité du circuit chargé de calculer les retenues. Cela peut se faire par l'utilisation de deux valeurs intermédiaires : la retenue propagée et la retenue générée. Nommées p et g, elles sont définies ainsi :

  • p, la retenue propagée sera égale à 1 si l'un des bits du cumulande ou cumulateur est à 1 : pi = Ai OUinclusif Bi.

  • g, la retenue générée sera égale à 1 si à la fois le bit en question du cumulande et du cumulateur sont à 1 : gi = Ai ET Bi.

Comme en base 10, si les deux chiffres à additionner forment un résultat supérieur à 9, alors une retenue est générée, et si deux chiffres forment le total 9, alors la retenue (éventuellement issue de la colonne de chiffres précédente) sera propagée. On peut facilement modifier un additionneur complet pour en extraire ces deux nouveaux signaux.

Ensuite, on peut constater que la retenue du second additionneur peut être facilement calculée : en effet, à partir du premier additionneur et de ses sorties p et g, la retenue sera à 1 si g est à 1 (elle est générée), ou bien p est à 1 en même temps qu'on a déjà une retenue. C’est-à-dire : R1 = g0 OU (p0 ET R0), et ainsi de suite :

  • R2 = g1 + (p1 . g0) + (p1 . p0 . r0)

  • R3 = g2 + (p2 . g1) + (p2 . p1 . g0) + (p2 . p1 . p0 . r0)

  • R4 = g3 + (p3 . g2) + (p3 . p2 . g1) + (p3 . p2 . p1 . g0) + (p3 . p2 . p1 . p0 . r0)

Additionneur 4 bits utilisant une unité de calcul anticipé de la retenue

On peut étendre ce principe à des additionneurs N bits, chacun composé de N additionneurs 1 bit et son unité de calcul anticipé de la retenue. Par exemple, un bloc de base avec N = 4 peut être représenté schématiquement comme ceci :

Additionneur 4 bits avec sorties P et G

Ces blocs sont à leur tour cascadables pour former un additionneur 16 bits :

Additionneur 16 bits à partir de blocs 4 bits

On obtient ainsi des additionneurs permettant de calculer un résultat en un temps logarithmique de la taille des entrées.

Additionneur série

Les premiers ordinateurs utilisaient un additionneur série. Ce circuit n'est plus combinatoire mais capable de produire un bit du résultat à chaque impulsion de l'horloge qui le cadence. Un tel circuit est extrêmement simple :

Additionneur série 1 bit. Le chronogramme schématise le déroulement de l'opération X + Y = S avec X = 5, Y = 7, S = 12.

Ce circuit est constitué de trois parties :

  1. la porte ET commandée par l'entrée L qui permet de spécifier l'arrivée du premier bit de poids faible dans le circuit ;

  2. une bascule de type D pour mémoriser la valeur de la retenue à l'étape précédente ;

  3. un additionneur complet 1 bit dont les entrées X et Y sont les nombres à ajouter et dont l'entrée Retenue est reliée à la sortie de la bascule D.

Le chronogramme indique bien que 5 (X) + 7 (Y) = 12 (S) (101 + 111 = 0011 en binaire, en lisant de droite à gauche). L'état des retenues Co et Coo est indiqué de manière purement informative.

Optimisation des additionneurs

Les additionneurs sont au cœur des unités arithmétique et logique des processeurs. Des techniques très particulières sont mises en œuvre pour additionner le plus vite possible, le plus souvent en utilisant des techniques complexes de prédiction de la retenue[1],[2]. Par exemple on peut détecter des blocs (série de bits consécutifs) ne générant pas de retenue, et donc très rapides à additionner. On peut aussi calculer deux résultats indépendamment et en parallèle, l'un avec une retenue, l'autre sans, et ensuite choisir le bon (via un multiplexeur). Dans ce cas, l'additionneur s'appellera un additionneur à sélection de retenue (Carry Select Adder).

Notes et références

  1. ↑ Définition d'un additionneur à retenue anticipée [archive] en langage VHDL.

  2. ↑ Génération à la volée du schéma d'un additionneur à retenue anticipée [archive], à partir de deux opérandes.

Voir aussi[modifier | modifier le code]

Sur les autres projets Wikimedia :

  • Logique séquentielle, sur Wikiversity

  • Logique combinatoire, sur Wikibooks

Liens internes[modifier | modifier le code]

  • Unité arithmétique et logique

  • Architecture des ordinateurs : comment synthétiser des portes logiques et des circuits ?

  • Système de numération d'Avizienis

Liens externes[modifier | modifier le code]

  • Simulateurs de différents circuits additionneurs [archive], du plus simple au plus complexe, en applet Java.

  • [PDF] High-speed binary adder [archive], H. Ling, 1981.


Langage machine — Wikipédia

Langage machines

Un article de Wikipédia, l'encyclopédie libre.

Encodage binaire du mot « Wikipedia ». 10100011101100100000001101111110010110101001010101010110111111001011010100101011111100101101010010

Le langage machine, ou code machine, est la suite de bits qui est interprétée par le processeur d'un ordinateur exécutant un programme informatique. C'est le langage natif d'un processeur, c'est-à-dire le seul qu'il puisse traiter. Il est composé d'instructions et de données à traiter codées en binaire.

Chaque processeur possède son propre langage machine, dont un code machine qui ne peut s'exécuter que sur la machine pour laquelle il a été préparé. Si un processeur A est capable d'exécuter toutes les instructions du processeur B, on dit que A est compatible avec B. L'inverse n'est pas forcément vrai : A peut avoir des instructions supplémentaires que B ne connaît pas.

Le code machine est aujourd'hui généré automatiquement, généralement par le compilateur d'un langage de programmation ou par l'intermédiaire d'un bytecode.

Instructions du langage

Article détaillé : Instruction informatique.

Les « mots » d'un langage machine sont appelés instructions. Chacune d'elles déclenche une commande de la part du processeur (par exemple : chercher une valeur dans la mémoire pour charger un registre, additionner deux registres, etc.).

Un processeur à architecture RISC ne reconnaît que peu d'instructions différentes, alors qu'un processeur à architecture CISC en possède un large éventail. Néanmoins certains processeurs CISC récents transforment en interne les instructions complexes en une suite d'instructions simples, qui sont alors exécutées.

Un programme est juste une longue séquence d'instructions qui sont exécutées par le processeur. Elles sont exécutées séquentiellement sauf quand une instruction de saut transfère l'exécution à une autre instruction que celle qui suit. Il existe également des sauts conditionnels qui sont soit exécutés (l'exécution continue à une autre adresse) ou ignorés (l'exécution continue à l'instruction suivante) selon certaines conditions.

Opcode

Chaque instruction commence par un nombre appelé opcode (ou code opération) qui détermine la nature de l'instruction. Par exemple, pour les ordinateurs d'architecture x86, l'opcode 0x6A (en binaire 01101010) correspond à l'instruction push (ajouter une valeur en haut de la pile). Par conséquent, l'instruction 0x6A 0x14 (01101010 00010100) correspond à push 0x14 (ajouter la valeur hexadécimale 0x14 , ou 20 en décimal, en haut de la pile).

Longueur des instructions

Certains processeurs codent toutes leurs instructions avec le même nombre de bits (par exemple : ARM, MIPS, PowerPC), tandis que chez d'autres la longueur de l'instruction dépend de l'opcode (exemple : x86). L'organisation des combinaisons de bits dépend largement du processeur. Le plus commun est la division en champs. Un ou plusieurs champs spécifient l'opération exacte (par exemple une addition). Les autres champs indiquent le type des opérandes, leur localisation, ou une valeur littérale (les opérandes contenus dans une instruction sont appelés immédiat).

Avantages et inconvénients

Lorsque toutes les instructions ont la même taille elles sont également alignées en mémoire. Par exemple si toutes les instructions sont alignées sur 32 bits (4 octets), alors les deux bits de poids faibles de l'adresse mémoire de n'importe quelle instruction sont à zéro. Cela permet notamment une implémentation plus aisée du cache des prédictions de branchement bimodales.

En revanche le code machine prend moins de place en mémoire s'il ne possède pas de taille minimum, étant donné qu'on élimine les champs non utilisés.

Écriture du code

Exemple de code binaire exécutable.

Bien que le langage machine était le seul disponible à l'aube des ordinateurs, il est aujourd'hui très long et fastidieux de développer en binaire ; il faut passer par un et souvent plusieurs langages intermédiaires.

De très nombreux langages de programmation sont transformés en langage machine lors de la compilation. Tous les programmes exécutables contiennent au moins une petite partie en langage machine.

Le langage le plus facile à convertir en code machine est l'assembleur car il possède quasiment les mêmes instructions. L'assembleur (ou langage assembleur) diffère d'une machine à une autre, bien que les instructions soient au bout du compte très semblables. Les langages de plus haut niveau sont convertis en assembleur pendant la compilation. Les langages utilisant une machine virtuelle passent par un bytecode qui est converti à la volée par la machine virtuelle.

Exemples

Processeur MIPS

Comme exemple spécifique, regardons l'architecture MIPS. Ses instructions ont toujours une longueur de 32 bits. Le type général de l'instruction est donné par les 6 bits de poids les plus forts (dans une représentation sur 32 bits, les 6 de gauche), qu'on appelle le champ op.

Les instructions de type-J et de type-I sont pleinement spécifiées par le champ op. Les instructions de type-R ont un champ supplémentaire, fonct, pour déterminer la nature exacte de l'opération. Les champs de ces 3 types d'instructions sont :

   6      5     5     5     5      6 bits
[  op  |  rs |  rt |  rd |shamt| fonct]  type-R
[  op  |  rs |  rt | adresse/immédiat ]  type-I
[  op  |        adresse cible         ]  type-J

rs, rt, et rd indiquent des opérandes de type registre ; shamt indique un décalage (shift amount) ; et le champ adresse ou immédiat contient un opérande sous forme de valeur.

Par exemple, ajouter les registres 1 et 2 et placer le résultat dans le registre 6 est codé :

[  op  |  rs |  rt |  rd |shamt| fonct]
    0     1     2     6     0     32     décimal
 000000 00001 00010 00110 00000 100000   binaire

Charger une valeur depuis la cellule mémoire 68 cellules après celle pointée par le registre 3 dans le registre 8 :

[  op  |  rs |  rt | adresse/immédiat ]
   35     3     8           68           décimal
 100011 00011 01000  0000000001000100    binaire

Sauter à l'adresse 1025 (la prochaine instruction à exécuter se trouve à l'adresse 1025) :

[  op  |        adresse cible         ]
    2                 1025               décimal
 000010   00000000000000010000000001     binaire

Processeur ARM

Les processeurs de l'architecture ARM sont un cas particulier dans la mesure où toutes les instructions sont conditionnelles. Elles sont toutes d'une longueur de 32 bits, et leurs 4 premiers bits indiquent dans quelles conditions l'instruction doit être exécutée.

Voir aussi

  • Langage assembleur dit de deuxième génération
  • Langage de haut niveau dit de troisième génération
  • L4G ou langage de quatrième génération
  • Processeur, la composante qui exécute le langage machine
  • Pipeline (informatique)


Instruction-machine — Wikipédia

Instruction-machine

Un article de Wikipédia, l'encyclopédie libre.

En informatique, une instruction machine est une opération élémentaire qu'un programme demande à un processeur d'effectuer. C'est l'ordre le plus basique que peut comprendre un ordinateur.

La collection d'instructions machine qui peuvent être données à un processeur est son jeu d'instructions. Les instructions machine sont codées en binaire. Un champ de l'instruction appelé « code opération » ou « opcode » désigne l'opération à effectuer. Puisque sa valeur numérique n'a pas de sens pour les humains, le programmeur utilise une abréviation désignant le code opération fourni par le langage assembleur pour ce processeur.

Taille des instructions

La taille d'une instruction dépend de l'architecture de la plateforme, mais elle est usuellement comprise entre 4 et 64 bits. Voici un exemple d'une instruction x86 dans la notation symbolique d'un langage assembleur :

SHL AX, 01

On appelle SHL un opérateur, et AX, 01 des opérandes. AX est le nom du registre, 01 est une constante. Dans cet exemple, SHL est une abréviation mnémonique pour « shift left » (décalage vers la gauche). L'instruction provoque le décalage vers la gauche d'un bit du registre AX.

Instructions les plus fréquentes

On peut classer les instructions qu'un microcontrôleur est capable d'effectuer en quelques groupes.

Instructions de transfert

Un processeur passe une grande partie de son temps à transférer des octets d'un endroit à l'autre du système : d'un périphérique vers un registre interne ou vice-versa, d'un registre interne vers la mémoire RAM ou vice-versa. Parfois, on ne peut pas effectuer de transfert direct d'une case mémoire vers une autre ou vers un périphérique, ou une écriture en mémoire ROM : il faut dans ce cas faire transiter les informations par l'un des registres internes. Remarquons que, sauf exception, il s'agit plutôt d'une copie que d'un transfert puisque la case mémoire d'origine garde son information (tant qu'on n'a pas écrit autre chose à la place).

Instructions arithmétiques

Les processeurs les plus simples ne permettent que d'effectuer des additions et des soustractions, voire des multiplications et des divisions sur des nombres entiers de la taille d'un mot. C'est notamment le cas des microcontrôleurs. Cependant, les processeurs modernes disposent généralement d'une unité de calcul en virgule flottante capable d'effectuer des calculs sur les nombres à virgule. En l'absence d'une telle unité, les nombres à virgule doivent être traitées en logiciel.

De même, certains anciens processeurs étaient capable d'effectuer des opérations mathématiques complexes telles que le traitement des grands nombres, des nombres fractionnaires, des puissances, des racines carrées, des fonctions trigonométriques, logarithmiques et exponentielles. Sur les processeurs modernes, ces opérations sont généralement réalisées en logiciel à l'aide des opérations mathématiques de base.

Instructions logiques

Les processeurs sont capables d'effectuer des opérations logiques : ET, OU, XOU (XOR), NON (inverseur), rotations, décalages. Les opérations sont opérées simultanément sur les bits correspondants des deux registres.

La comparaison des octets A et B, qui est considérée comme une opération logique, est réalisée comme une soustraction dont on néglige le résultat ; on s'intéresse simplement au fait de savoir s'il est nul (ce qui signifie que A = B), positif (A > B) ou négatif (A < B). Ces indications sont inscrites dans des indicateurs d'états (petites mémoires d'un bit situées dans le processeur).

Instructions d'entrées/sorties

Ces instructions permettent de s'interfacer avec des dispositifs extérieurs, via des ports d'entrée/sortie. Dans certaines architectures, les ports sont considérés simplement comme des cases de mémoire et ils sont gérés par les instructions de transfert (entrées/sorties intégrées mémoire). D'autres architectures disposent d'instructions spécifiques pour les entrées/sorties (entrées/sorties indépendantes).

Instructions de branchement

Il s'agit d'instructions qui altèrent le déroulement normal du programme. On distingue les sauts et les sous-routines :

  • les sauts provoquent un branchement du programme vers une adresse mémoire qui n'est pas contiguë à l'endroit où l'on se trouve ;
  • une sous-routine ou un sous-programme est une partie de programme dont on a besoin à plusieurs endroits dans l'exécution du programme principal. Plutôt que de répéter ce sous-programme à tous les endroits où l'on en a besoin, on le place en un endroit donné (par exemple à la fin du programme principal) et on opère un branchement du programme principal vers le sous-programme chaque fois que nécessaire. La grande différence par rapport au saut, c'est qu'au moment du branchement il faut mémoriser l'adresse d'où l'on vient, afin de pouvoir y revenir une fois le sous-programme terminé. Ceci est effectué en mémorisant l'adresse de départ dans un registre ad hoc (la pile) du microcontrôleur.

Tant les sauts que les sous-routines peuvent être :

  • inconditionnels ;
  • conditionnels, c'est-à-dire que le branchement n'a lieu que si une certaine condition est remplie ; généralement, la condition testée est le contenu d'un des indicateurs d'état ; ceux-ci indiquent par exemple si le contenu de l'accumulateur est nul, positif, négatif, de parité paire ou impaire.

Instructions diverses

On trouve dans ce groupe :

  • des instructions de gestion de la pile (zone de mémoire RAM permettant le stockage de données pendant l'exécution du programme) ;
  • des instructions de contrôle du processeur : par exemple passage en mode basse consommation, contrôle des périphériques embarqués (c'est-à-dire situés sur la même puce que le processeur) ;
  • des instructions permettant de positionner des indicateurs internes du processeur.

Voir aussi

  • Langage machine
  • Mode d'adressage


Mode d'adressage — Wikipédia

Mode d'adressage

Un article de Wikipédia, l'encyclopédie libre.

Les modes d'adressages sont un aspect de l'architecture des processeurs et de leurs jeux d'instructions. Les modes d'adressages définis dans une architecture régissent la façon dont les instructions en langage machine identifient leurs opérandes. Un mode d'adressage spécifie la façon dont est calculée l'adresse mémoire effective d'un opérande à partir de valeurs contenues dans des registres et de constantes contenues dans l'instruction ou ailleurs dans la machine.

En programmation informatique, les personnes préoccupées par les modes d'adressage sont principalement celles qui programment en assembleur et les auteurs de compilateurs.

Modes d'adressage pour les branchements

adresse de la prochaine instruction à exécuter est contenue dans un registre spécial du processeur, appelé compteur ordinal (CO) ou compteur de programme. Les instructions de branchement (ou de saut) visent à modifier la valeur du compteur ordinal. Cette valeur est l'adresse effective de l'instruction de branchement ; elle est calculée différemment selon le mode d'adressage choisi.

Adressage absolu

Branchement absolu.

En adressage absolu, l'adresse de destination est donnée dans l'instruction ; on peut donc se rendre n'importe où dans la mémoire (programme). Au moment du branchement, le contenu du pointeur de programme est remplacé par l'adresse en question (si le branchement concerne un sous-programme, on sauvegarde le contenu du pointeur de programme).

Adressage relatif

Branchement relatif.

Comme de nombreux branchements s'effectuent vers des adresses mémoire proches de l'endroit où l'on se trouve au moment d'exécuter le branchement, on peut se contenter d'indiquer un décalage par rapport à l'adresse de la prochaine instruction. Par exemple si l'on exécute du code à l'adresse 0x42 et que l'on veut brancher 8 octets plus loin, on peut simplement indiquer +8 pour brancher à 0x4A au lieu d'indiquer cette adresse complète.

Ce mode d'adressage a deux avantages comparé au mode d'adressage absolu. Premièrement, il diminue la quantité de mémoire utilisée par le programme. Cela vient du fait que le décalage prend beaucoup moins de bits qu'une adresse.

Ensuite, ces branchements facilitent l'implémentation de programmes relocalisables, qui peuvent être placés n'importe où en mémoire. C'est une fonctionnalité utilisée pour les bibliothèques dynamiques, qui peuvent être chargées par plusieurs processus à des emplacements différents de leur mémoire : le code n'a pas besoin d'être modifié pour s'adapter à des adresses différentes si les branchements sont relatifs, et peut donc être partagé.

Adressage indirect

Branchement indirect.

Dans certains cas, l'adresse à laquelle brancher n'est pas connue à la compilation, ou alors celle-ci peut varier selon les circonstances. Cela arrive lorsqu'un programme utilise des pointeurs sur fonction, ou lors de l’utilisation de certains fonctionnalités d'un langage (RTTI, Dynamic Dispatch, etc). Auparavant, on réglait ce genre de situation via du code auto-modifiant. Mais de nos jours, certains processeurs ont réglés ce problème en incorporant un mode d'adressage indirect pour le code.

Avec ce mode d'adressage, l'adresse vers laquelle brancher est stockée dans un registre. Le nom du registre en question est alors incorporé dans la représentation binaire de l'instruction.

Modes d'adressage pour les données

De nombreuses instructions font référence à des données se trouvant à différents endroits du processeur : registres, mémoire, ports d'E/S.

Adressage implicite

Certaines opérations ne peuvent être réalisées que sur une donnée se trouvant en un endroit bien précis du processeur (par exemple, l'accumulateur ou la pile). Dans ce cas, il n'est pas nécessaire de spécifier l'adresse du registre en question et on parle d'adressage implicite.

Adressage immédiat

Adressage immédiat.

C'est un peu un abus de langage que de parler d'adressage dans ce cas-ci. En effet, la donnée est intégrée directement dans la représentation binaire de l'instruction. Ce mode d'adressage permet d'optimiser la gestion des constantes connues à la compilation.

Généralement, les processeurs utilisant ce mode d'adressage utilisent une dizaine de bit pour encoder des opérandes. Diverses études, effectuées par Andrew Tannenbaum, ont montrée qu'une grande partie (entre 75 et 90 %) des constantes numériques d'un programme pouvaient tenir sur 14 à 13 bits. Utiliser plus de bits serait donc inutile.

Ce mode d'adressage est utilisé pour des constantes numériques entières. Ce mode d'adressage est rarement utilisé pour des constantes flottantes, en raison de leur grande taille : 32 à 64 bits sur de nombreux processeurs.

Adressage direct

Adressage direct.

Dans ce mode d'adressage, on donne l'adresse de la donnée en mémoire (RAM, ROM ou port d'E/S s'il est intégré à la mémoire). Ce mode d'adressage permet d'indiquer n'importe quel endroit dans la mémoire, le prix à payer étant que l'on doit spécifier l'adresse concernée dans son intégralité.

Ce mode d'adressage permet parfois de lire ou d'écrire une donnée directement depuis la mémoire sans devoir la copier dans un registre.

De nos jours, ce mode d'adressage ne sert que pour les données dont l'adresse est fixée une bonne fois pour toute. Les seules données qui respectent cette condition sont les données placées dans la mémoire statique. Pour les programmeurs, cela correspond aux variables globales et aux variables statiques, ainsi qu'à certaines constantes (les chaines de caractères constantes, par exemple).

Autrefois, ce mode d'adressage servait pour toutes les adresses mémoire, y compris celles qui pouvaient varier, comme les adresses utilisées pour manipuler des tableaux. On devait alors utiliser du code auto-modifiant pour faire varier les adresses encodées avec l'adressage direct.

Adressage registre ou inhérent

Adressage inhérent.

Le processeur dispose d'un certain nombre de registres de travail. Ces registres servent à stocker des données, pour qu'elles puissent servir d'opérandes pour nos instructions machines. De nombreuses instructions y font référence.

Pour sélectionner un registre parmi tous les autres, ceux-ci se voient attribuer un numéro, un identifiant, qu'on appelle un nom de registre. Vu leur nombre peu élevé de registres d'un processeur(8, par exemple), il suffit d'un petit nombre de bits pour spécifier cet identifiant directement dans l'instruction manipulant ce registre. On parle dans ce cas d'adressage registre ou inhérent.

Le nombre de bits utilisé pour encoder nos registres dépend fortement du nombre de registres, mais aussi de la spécialisation de ces mêmes registres. Sur certains processeurs, les registres sont regroupés en grands ensembles bien séparés. Par exemple, on peut avoir des registres flottants séparés des registres généraux. Et il se peut que les instructions soient cantonnées à un ensemble de registre : par exemple, on aura des instructions séparées pour les registres flottants et d'autres pour les entiers. Dans ce cas, les identifiants sont spécifiques à un ensemble de registre. Ainsi, un registre flottant pourra réutiliser le même identifiant qu'un registre entier : c'est l'instruction utilisée qui sélectionnera implicitement le bon ensemble de registres.

Ce mode d'adressage n'est pas présent sur toutes les architectures : les processeurs basés sur la pile, et certains processeurs à accumulateurs s'en passent.

Adressage indirect à registre

Adressage indirect à registre.

Dans ce mode d'adressage, l'adresse de la donnée se trouve dans un registre du processeur. Ce mode d'adressage permet de préciser dans quel registre se trouve l'adresse de la donnée à accéder. On retrouve donc un nom de registre dans notre instruction, mais celui-ci ne sera pas interprété de la même manière que dans le mode d'adressage inhérent.

Le mode d'adressage indirect à registre permet d'implémenter de façon simple ce qu'on appelle les pointeurs. Au début de l'informatique, les processeurs ne possédaient pas d'instructions ou de modes d'adressages pour gérer les pointeurs. On pouvait quand même gérer ceux-ci, en utilisant l'adressage direct. Mais dans certains cas, forçait l'utilisation de self-modifying code, c'est-à-dire que le programme devait contenir des instructions qui devaient modifier certaines instructions avant de les exécuter ! En clair, le programme devait se modifier tout seul pour faire ce qu'il faut. L'invention de ce mode d'adressage a permis de faciliter le tout : plus besoin de self-modifying code.

Adressage indirect à registre avec incrément ou décrément

Adressage indirect à registre post-incrémenté.

Le mode d'adressage indirect à registre existe aussi avec une variante : l'instruction peut automatiquement augmenter ou diminuer le contenu du registre d'une valeur fixe.

Cela permet de faciliter l'implémentation des parcours de tableaux. Il n'est pas rare qu'un programmeur ait besoin de traiter tous les éléments d'un tableau. Pour cela, il utilise une suite d'instructions qu'il répète sur tous les éléments : il commence par traiter le premier, passe au suivant, et continue ainsi de suite jusqu’au dernier. À chaque étape, l'adresse de l’élément à accéder est augmenté ou diminué d'une valeur fixe. Ce mode d'adressage permet d'effectuer cette incrémentation ou décrémentation automatiquement.

Adressage indéxé absolu

Adressage indexé absolu.

Ce mode d'adressage cherche à faciliter l'utilisation des tableaux en assembleur. Un tableau est un ensemble de données de même taille, placées les unes à coté des autres en mémoire. Pour accéder à un élément d'un tableau, le programmeur doit obligatoirement calculer son adresse et effectuer une lecture/écriture. Grâce au mode d'adressage indexé absolu, des deux opérations peuvent être effectuées par une seule instruction.

Le calcul d'adresse est assez simple : elle vaut [image], en posant :

  • L la longueur d'un élément du tableau ;
  • i l'indice de cet élément ;
  • et A l'adresse de début du tableau (l'adresse de l’élément d'indice zéro).

Notre mode d'adressage utilise ces données pour calculer l'adresse de l’élément voulu avant de le lire ou de l'écrire.

Adressage Base + Index

Base + Index.

Le mode d'adressage indéxé absolu ne fonctionne que pour les tableaux dont l'adresse de base est fixée une fois pour toute. Or, dans la majorité des cas, les tableaux sont alloués via l'allocation dynamique et on une adresse de base qui n'est pas connue à la compilation. Celle-ci change donc à chaque exécution, rendant l'adressage indexé absolu assez difficile à utiliser.

Pour contourner les limitations du mode d'adressage indéxé absolu, on a inventé le mode d'adressage Base plus index. Avec ce dernier, l'adresse du début du tableau n'est pas stockée dans l'instruction elle-même, mais dans un registre. Elle peut donc varier autant qu'on veut.

Ce mode d'adressage spécifie deux registres dans sa partie variable : un registre qui contient l'adresse de départ du tableau en mémoire : le registre de base ; et un qui contient l'indice : le registre d'index.

Adressage Base + Offset

Base + Offset.

Le mode d'adressage Base + Offset a étè inventé pour gérer les structures de façon plus efficace. Ces structures sont des rassemblement de données élémentaires, manipulables par le processeur, comme des pointeurs, des entiers, des flottants, etc. Ces données sont placées les unes après les autres en mémoire.

Pour sélectionner une donnée dans une structure, le processeur doit calculer son adresse. Vu que cette donnée a toujours une place bien précise dans la structure, on peut repérer celle-ci à partir de l'adresse de début de notre structure : il suffit de rajouter le nombre de bytes qui séparent notre donnée du début de la structure.

Cette addition entre l'adresse de base et ce nombre de bytes est effectué automatiquement avec l'adressage Base + Offset. L'adresse et le décalage sont stockés dans deux registres.

Modes d'adressages spécialisés pour les Digital Signal Processors

Certains processeurs spécialisés dans le traitement de signal supportent des modes d'adressage spécialisés, afin d'accèlèrer des traitements et des calculs qu'on trouve couramment dans le traitement de signal. La gestion de files ou les calculs de FFT peuvent ainsi être accélérés par l'utilisation de ces modes d'adressages spécialisés. Deux de ces modes d'adressages sont couramment présents dans les processeurs de traitement de signal (les DSP) : l'adressage modulo, et l'adressage bit-reverse.

Adressage Modulo

Les DSPs implémentent des modes d'adressages servant à faciliter l’utilisation de files, des structures de données spéciales, utilisées occasionnellement par les programmeurs de DSP. Ces structures sont des zones de mémoire dans lesquelles on stocke des données dans un certain ordre. On peut y ajouter de nouvelles données, et en retirer. Quand on retire une donnée, c'est la donnée la plus ancienne qui quitte la file.

Fonctionnement d'une file - 2.

Ces files sont implémentées avec un tableau, auquel on ajoute deux adresses mémoires : une pour indiquer le début de la file, et l'autre la fin. Le début de la file correspond à l'endroit en mémoire où l'on va insérer les nouvelles données. La fin de la file correspond à la position de la donnée la plus ancienne en mémoire.

À chaque ajout de donnée, l'adresse de la donnée la plus récente est augmentée de la taille de la donnée, afin de réserver la place pour la donnée à ajouter. De même, lors d'une suppression, le pointeur de la donnée la plus ancienne est aussi augmenté, afin de libérer la plus place qu'il occupait.

Fonctionnement d'une file - 3.

Ce tableau a une taille fixe. Si jamais celui-ci se remplit jusqu'à la dernière case, (ici la 5e), il se peut malgré tout qu'il reste de la place au début du tableau : des retraits ont libéré de la place. L'insertion des données reprend au tout début du tableau.

Ce mode de fonctionnement nécessite de vérifier à chaque insertion si l'on a atteint la fin du tableau, avec l'aide d'une comparaison entre adresses De plus, si l'on arrive à la fin du tableau, l'adresse de la donnée la plus récemment ajoutée doit être remise à la bonne valeur : celle pointant sur le début du tableau.

Le mode d'adressage modulo a été inventé pour supprimer la comparaison et la gestion logicielle des débordements. Avec ce mode d'adressage, les deux adresses sont adressées en utilisant le mode d'adressage indirect à registre post ou pré-indexé : l'incrémentation de l'adresse au retrait ou à l'ajout est effectué automatiquement. Ce mode d'adressage vérifie automatiquement que l'adresse ne déborde pas du tableau lors d'une insertion. Si cette adresse "déborde", le processeur la fait pointer au début du tableau. Suivant le DSP, ce mode d'adressage est géré plus ou moins différemment.

La première méthode utilise des registres modulos. Ces registres vont stocker la taille du tableau servant à implémenter notre file. Chacun de ces registres est associé à un registre d'adresse : si jamais on utilise l'adressage modulo dans ce registre d'adresse, le processeur utilisera le contenu du registre modulo pour faire ce qu'il faut. Pour gérer l'adresse de début, le processeur va imposer quelques contraintes sur l'adresse de départ de ce tableau. Cette adresse est souvent alignée à des adresses bien précises, souvent un multiple de 64, 128, ou 256. L'adresse de début de la file est donc le multiple de 64, 128, 256 strictement inférieur le plus proche de l'adresse manipulée.

Autre solution : utiliser deux registres : un pour stocker l'adresse de début du tableau, et un autre pour sa longueur. Certains processeurs DSP utilisent un registre pour stocker l'adresse de début, et un autre pour l'adresse de fin.

Adressage Bit Reverse

Le mode d'adressage bit-reverse sert à accélérer les calculs de transformées de Fourier rapides. Ces algorithmes vont prendre des données, stockées dans un tableau, et fournir des résultats, eux aussi écrits dans un tableau. L'ordre de calcul des résultats dans le tableau d'arrivée suit une logique particulière. Les bits de l'adresse du résultat sont partiellement inversés comparé aux bits de l'adresse normale.

Par exemple, pour un tableau de 8 cases, numérotées 0,1, 2, 3, 4, 5, 6, 7, les données arrivent dans cet ordre : 0, 4, 2, 6, 1, 5, 3, 7.

Ordre normal | Ordre FFT
000 | 000
001 | 100
010 | 010
011 | 110
100 | 001
101 | 101
110 | 011
111 | 111

Les DSPs disposent d'un mode d’adressage qui inverse tout ou partie des bits d'une adresse mémoire, afin de gérer plus facilement les calculs de FFT. Une autre technique consiste à calculer nos adresses différemment. Lors de l'ajout d'un indice à notre adresse, la direction de propagation de la retenue de l'addition est inversée. Certains DSP disposent d'instructions pour faire de genre de calculs.


Algèbre de Boole (logique) — Wikipédia

Algèbre de Boole (logique)

Un article de Wikipédia, l'encyclopédie libre.

L'algèbre de Boole, ou calcul booléen, est la partie des mathématiques, de la logique et de l'électronique qui s'intéresse aux opérations et aux fonctions sur les variables logiques. Plus spécifiquement, l'algèbre booléenne permet d'utiliser des techniques algébriques pour traiter les expressions à deux valeurs du calcul des propositions. Elle fut initiée en 1854 par le mathématicien britannique George Boole.

Aujourd'hui, l'algèbre de Boole trouve de nombreuses applications en informatique et dans la conception des circuits électroniques. Elle fut utilisée la première fois pour les circuits de commutation téléphoniques par Claude Shannon.

Exemple introductif

L'algèbre de Boole des fonctions logiques permet de modéliser des raisonnements logiques, en exprimant un « état » en fonction de conditions. Par exemple dans les expressions

Communication = Émetteur ET Récepteur

Communication serait « VRAI » si à la fois Émetteur ET Récepteur étaient actif (c'est une fonction logique dépendant des variables Émetteur et Récepteur)

Décrocher = ( Décision de répondre ET Sonnerie ) OU décision d'appeler

Décrocher serait « VRAI » soit si à la fois on entend la sonnerie ET l'on décide de répondre, soit (OU) si simplement l'on décide d'appeler.

L'algèbre de Boole étant un domaine commun à trois disciplines, on rencontre des notations différentes pour désigner un même objet. Dans le reste de l'article, on indiquera les diverses notations, mais on en privilégiera une pour conserver une certaine homogénéité.

Algèbre de Boole des valeurs de vérité

On appelle B l'ensemble constitué de deux éléments appelés valeurs de vérité {VRAI, FAUX}. Cet ensemble est aussi noté

  • B = {1, 0}
  • B = [image].

On privilégiera dans la suite la notation B = {1, 0}.

Sur cet ensemble on peut définir deux lois (ou opérations ou foncteurs), les lois ET et OU et une transformation appelée complémentaire, inversion ou contraire.

Conjonction

Articles connexes : Fonction ET et Conjonction logique.

Table de la loi ET
b\a | 0 | 1
0 | 0 | 0
1 | 0 | 1

Elle est définie de la manière suivante : a ET b est VRAI si et seulement si a est VRAI et b est VRAI. Cette loi est aussi notée

  • « & » ou « && » dans la plupart des langages de programmation (Perl, C, PHP…)
  • « AND » dans certains langages de programmation (Ada, Pascal, Perl, Python, PHP…)
  • « ∧ » dans quelques notations algébriques, ou en APL
  • « * » (une multiplication ordinaire), pour quelques langages ne disposant pas de fonction adaptée

On privilégiera dans la suite la notation [image].

On peut construire la table de cette loi (comme une table d'addition ou de multiplication de notre enfance) mais on ne la confondra pas avec une table de vérité.

Disjonction

Table de la loi OU
b\a | 0 | 1
0 | 0 | 1
1 | 1 | 1

Elle est définie de la manière suivante : a OU b est VRAI si et seulement si a est VRAI ou b est VRAI. (En particulier, si a est vrai et que b est vrai aussi, alors a OU b est vrai.) Cette loi est aussi notée

  • « ∨ » (« [image] ») en mathématiques (et en logique mathématique) ou en APL.
  • « | » ou « || » dans certains langages de programmation
  • En toute lettre « or » ou « OR » en logique ou dans certains langages de programmation ..

On privilégiera dans la suite la notation + mais on prendra garde que cette loi n'est pas l'addition usuelle dans Z/2Z. C'est pourquoi, en mathématiques et en logique mathématique, la notation + n'est pas utilisée pour désigner le "ou inclusif" : elle est réservée au "ou exclusif", opération qui (jointe au "et") fait de toute algèbre de Boole un anneau de Boole, en particulier une Z/2Z-algèbre.

Négation

Le contraire de "a" est VRAI si et seulement si a est FAUX. Le contraire de a est noté

  • non-a
  • « ! » dans quelques langages de programmation (C, C++…)
  • « NOT » dans certains langages de programmation (ASM…)
  • « ~ » dans quelques notations algébriques, en APL et dans quelques langages d'interrogation de bases de données (SQL…).
  • « 1- » dans quelques langages ne disposant pas de fonction adaptée (Batch…) (puisque 1-0=1 et 1-1=0)

On privilégiera dans la suite la notation [image].

On obtient alors [image] et

Propriétés

Propriétés des opérateurs

Associativité

Comme avec les opérations habituelles, certaines parenthèses sont inutiles:

( a + b ) + c = a + (b + c) = a + b + c

( a . b ) . c = a . (b . c) = a . b . c

Commutativité

L'ordre est sans importance:

a + b = b + a

a . b = b . a

Distributivité

a . ( b + c ) = a . b + a . c

a +( b . c ) = ( a + b ) . ( a + c )

Idempotence

a + a + a + [...] + a = a

a . a . a . [...] . a = a

Éléments neutres

Absorption

0 . a = 0

Simplification

Redondance

Complémentarité

(« La lumière est allumée » = « la lumière n'est pas non allumée »)

(« VRAI » SI lumière_allumée OU SI lumière_non_allumée → c'est toujours le cas → vrai dans tous les cas → toujours VRAI, donc =1)

(«FAUX » SI lumière_allumée ET SI lumière_non_allumée → impossible → faux dans tous les cas → toujours FAUX, donc =0)

Structure

On retrouve alors toutes les propriétés qui confèrent à B une structure d'algèbre de Boole

Priorité

Pour faciliter leur compréhension, il a été décidé que ces opérations seraient soumises aux mêmes règles que les opérations « de tous les jours », la fonction ET (multiplication logique) est ainsi prioritaire par rapport à la fonction OU (somme logique) ; on peut, pour s'aider, placer des parenthèses dans les opérations.

Exemple :

{ a = 0 ; b = 1 ; c = 1 }
On cherche a . b + c = ???

Solution

D'abord on calcule a . b :
a . b = 0 . 1
0 . 1 = 0
Puis, on calcule 0 + c :
0 + c = c
c = 1
Le résultat final est donc:
a . b + c = ( a . b )+ c = 1

Théorème de De Morgan[modifier | modifier le code]

Première loi de De Morgan (négation de la conjonction)

s'exprime par l'égalité suivante

Table de vérité/Table de fonctionnement
a | b | a+b |  |  |  |
0 | 0 | 0 | 1 | 1 | 1 | 1
0 | 1 | 1 | 0 | 1 | 0 | 0
1 | 0 | 1 | 0 | 0 | 1 | 0
1 | 1 | 1 | 0 | 0 | 0 | 0

Dans les deux cas, l'expression ne sera VRAIE
que si a et b sont fausses.

Deuxième loi de De Morgan (négation de la disjonction)

Table de vérité/Table de fonctionnement
a | b | a . b |  |  |  |
0 | 0 | 0 | 1 | 1 | 1 | 1
0 | 1 | 0 | 1 | 1 | 0 | 1
1 | 0 | 0 | 1 | 0 | 1 | 1
1 | 1 | 1 | 0 | 0 | 0 | 0

Dans les deux cas, l'expression ne sera FAUSSE
que si a et b sont vraies.

Fonctions logiques

Mathématiquement, une fonction logique ou opérateur logique est une application de Bn dans B.

En électronique, une fonction logique est une boîte noire qui reçoit en entrée un certain nombre de variables logiques et qui rend en sortie une variable logique dépendant des variables d'entrée. L'article fonction logique précise comment construire les boîtes noires de quelques fonctions fondamentales.

Une table de vérité permet de préciser l'état de la sortie en fonction des états des entrées. Elle caractérise la fonction logique.

Toute table de vérité, et donc toute fonction logique, peut se décrire à l'aide des trois opérations de base :

  • disjonction (OU)
  • conjonction (ET)
  • négation (NON)

On démontre aussi qu'il existe exactement [image] fonctions logiques de n paramètres. Il suffit en effet de considérer toutes les tables de vérités possibles, ou de considérer le développement d'une fonction de n paramètres

Fonctions logiques fondamentales

Elles sont issues des trois opérations de base et définissent alors

  • une fonction de B dans B : le complémentaire ou inversion
  • deux fonctions de B2 dans B qui sont la somme (OU) et le produit (ET)

Table de vérité de l'inverse
a |
0 | 1
1 | 0

Table de vérité de la somme
a | b | a [image] b
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

Table de vérité du produit
a | b | a [image] b
0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

Fonctions logiques composées

Ce sont les fonctions logiques à deux variables. Parmi celles-ci, on en dénombre certaines suffisamment intéressantes pour qu'on leur donne un nom.

Disjonction exclusive

Table de vérité de XOR
a | b | a [image] b
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

Article connexe : OU exclusif.

Le OU étudié jusqu'à présent doit se comprendre de la manière suivante : « l'un ou l'autre ou les deux ». Il est également appelé « OU inclusif ». Le OU exclusif (ou XOR pour ' eXclusive OR') s'entend comme : « l'un ou l'autre, mais pas les deux ».

a\ \operatorname{XOR}\ b

On peut également le définir avec un modulo sur une somme ordinaire :

Le « ou exclusif » est parfois noté par le signe arithmétique [image] (différent de). Fonctionnellement, on utilise aussi un + entouré: .

Équivalence

Table de vérité de EQV
a | b | a [image] b
0 | 0 | 1
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

L'équivalence (notée EQV ou XNOR) est vraie si les deux entrées ont la même valeur et fausse sinon. C'est la négation du « ou exclusif ».

L'équivalence peut s'écrire

L'équivalence est souvent notée par le signe [image]. Elle peut aussi être notée "==" dans certains langages (C, C++, PHP…).

Implication

Table de vérité de IMP
a | b | a [image] b
0 | 0 | 1
0 | 1 | 1
1 | 0 | 0
1 | 1 | 1

Article détaillé : implication (logique).

L'implication (notée IMP) s'écrit de la manière suivante

Cette opération n'est pas commutative. a est une condition suffisante pour b, qui, elle, est une condition nécessaire pour a.

Mais

illustration :

de l'affirmation "Si j'habite en France, alors j'habite en Europe." on peut déduire "Si je n'habite pas en Europe, alors je n'habite pas en France." mais pas "Si je n'habite pas en France, alors je n'habite pas en Europe. car on ne sait pas si j'habite en Europe mais ailleurs qu'en France..

Inhibition

Table de vérité de INH
a | b |
0 | 0 | 0
0 | 1 | 0
1 | 0 | 1
1 | 1 | 0

L'inhibition (notée INH) se compose comme suit

Si a est VRAI, l'expression vaut VRAI, SAUF si b est VRAI.

Cette opération n'est pas commutative.

Exemple de fonctions logiques à trois ou quatre variables

Fonction logique à trois variables

Table de vérité de décrocher
a | b | c | d
0 | 0 | 0 | 0
0 | 0 | 1 | 1
0 | 1 | 0 | 0
0 | 1 | 1 | 1
1 | 0 | 0 | 0
1 | 0 | 1 | 1
1 | 1 | 0 | 1
1 | 1 | 1 | 1

L'égalité Décrocher = ( Sonnerie ET Décision de répondre ) OU Décision d'appeler traduit la situation pratique suivante : On décroche un téléphone quand on décide d'appeler quelqu'un ou lorsque le téléphone sonne et qu 'on décide de répondre.

Elle est constituée de trois variables :

  • a = "Sonnerie"
  • b = "Décision de répondre"
  • c = "Décision d'appeler"

la variable d = "Décrocher" est fonction logique des 3 précédentes et peut s'écrire d = a.b + c

La table de vérité de cette fonction d est alors la suivante (à droite) :

Table de vérité de décrocher2
a | b | c | d2
0 | 0 | 0 | 0
0 | 0 | 1 | 1
0 | 1 | 0 | 0
0 | 1 | 1 | 1
1 | 0 | 0 | 0
1 | 0 | 1 | 0
1 | 1 | 0 | 1
1 | 1 | 1 | 1

L'observation de la table met en évidence une situation absurde : quand on décide d'appeler quelqu'un et que le téléphone sonne sans qu'on ait envie de répondre, on décrocherait quand même. Une modification de la table comme ci-contre corrigerait cette absurdité. Cette table correspond à une fonction logique Décrocher2 ou d2 qu'il est possible de déterminer et simplifier en [image].

Fonction logique à quatre variables

Un bon élève s'interroge s'il est sage de sortir un soir. Il doit décider en fonction de quatre variables :

  • a = il a assez d'argent
  • b = il a fini ses devoirs
  • c = le transport en commun est en grève
  • d = l'automobile de son père est disponible

Cet élève pourra sortir si :

  • il a assez d'argent, a = vrai
  • il a fini ses devoirs, donc b = vrai
  • le transport en commun n'est pas en grève, donc c = faux
  • ou si l'automobile de son père est disponible, donc d = vrai

L'expression logique de sortir en fonction de l'état des variables a, b, c et d peut donc s'écrire ainsi :

Sortir =

Minimisation d'une expression

Une fonction logique peut être déterminée

  • soit sous forme d'une expression faisant intervenir les 3 opérations ( [image], [image], )
  • soit sous forme de sa table de vérité. Dans ce cas il sera toujours possible d'effectuer un développement pour écrire cette fonction comme une somme de produits.

Exemple: Dans l'exemple de "Décrocher2", la lecture de la table montre que d2 égale 1 quand (a, b, c) = (0, 0, 1) ou (0, 1, 1) ou (1, 1, 0) ou (1, 1, 1).

Cela permet de définir d2 par

Il est possible de trouver une expression minimisant le nombre de termes et le nombre de lettres dans chaque terme. C'est l'objectif de certaines techniques comme la méthode de Quine-Mc Cluskey, les diagrammes de Karnaugh, la méthode des consensus, la double dualisation…

Exemple (suite) : la somme précédente peut être réduite en

par factorisation des deux premiers termes par [image] et factorisation des deux derniers termes par

Arbre d'expression

Les expressions logiques sont souvent représentées en informatique sous forme d'arborescence. À un premier sommet (racine) sont rattachés différents sous-arbres (ou branches). Les sommets sans issue sont appelés feuilles. Chaque sommet interne correspond à un sélecteur booléen S(x, y, z )= "si x alors y sinon z", qui ramène une question x à deux sous-questions plus simples, éventuellement réduites à 1/vrai ou 0/faux. L'évaluation d'une fonction f dépendant d'une variable q choisie pour la première question est alors f=S(q,f(q=1), f(q=0)), qui ramène à deux expressions indépendantes de q. Soit f = a.b+a.d.f+c.d+e.f ; on peut écrire f= S(a, f(a=1), f(a=0))= S(a, b+c.d+d.f+e.f, c.d+e.f)= S(a, S(b,1,d.f+c.d+e.f), S(c,d+e.f, e.f))... Les arbres dépendant de l'expression et de l'ordre des questions, pour une même expression certains questionnaires seront plus simples que d'autres.

Bibliographie

Kuntzmann J., 1968, Algèbre de Boole, Paris:Dunod.

Picard, C.F, 1965, Théorie des questionnaires, Paris:Gauthier-Villars.

Voir aussi

Sur les autres projets Wikimedia :

· Logique séquentielle, sur Wikiversity

· Électronique numérique : logique, sur Wikibooks

  • Fonction logique
  • Calcul des propositions
  • Système de numération
  • Électronique numérique
  • Neurone formel
  • George Boole
  • Opération bit à bit


Logique de base/Algèbre de Boole — Wikiversité

Logique de base/Algèbre de Boole

Une page de Wikiversité.

Introduction

Dérivée des mathématiques, l'algèbre de Boole est utilisée par les automaticiens afin de réduire les équations logiques pour éviter de prendre trop de place dans les mémoires d'automates programmables. À l'époque, et pour les automatismes assez importants, la mémoire était un critère important : Il fallait par tous les moyens possibles réduire au minimum cette prise de place.
L'algèbre de Boole est un très bon outil utilisant des règles relativement simples. En algèbre de Boole les variables (a, b, c ....) ne peuvent prendre que deux valeurs : 0 et 1

Les propriétés

Tout d'abord les symboles utilisés en algèbre de Boole bien qu'en apparence similaire à ceux des mathématiques diffèrent dans leurs significations. Ainsi

  • le symbole " + " se lit " ou ". En effet l'expression " a + b = 1 " se lit " a ou b égal à 1 ". Cette condition est vérifiée pour a ou pour b (ou pour les deux en même temps) égale à 1
  • le symbole " . " se lit " et ". En effet l'expression " a . b = 1 " se lit " a et b égal à 1 ". Cette condition est vérifiée pour a et b égal à 1. (Si l'un des deux vaut 0, l'équation n'est pas vérifiée)
  • la variable " [image] " se lit " a barre". Elle prend la valeur opposé de a. Si a = 1 alors [image] = 0 et inversement.

Propriété de la somme

  • a + 1 = 1
  • a + 0 = a
  • a + a = a
  • a + [image] = 1

Propriété du produit

  • a . 1 = a
  • a . 0 = 0
  • a . a = a
  • a . = 0

Propriété de la négation

Propriété de la commutativité

  • a + b = b + a
  • a . b = b . a

Propriété de l'associativité

  • a + b + c = ( a + b ) + c = a + ( b + c )
  • a . b . c = ( a . b ) . c = a . ( b . c )

Propriété de la distributivité

  • a . ( b + c ) = a.b + a.c
  • ( a + b ) . ( c + d ) = a.c + a.d + b.c + b.d
  • a + ( b . c ) = (a+b) . (a+c)

Théorème de De Morgan


Fonction logique — Wikipédia

Fonction logique

Un article de Wikipédia, l'encyclopédie libre.

Il existe deux grands types de fonctions logiques :

  • les fonctions logiques « combinatoires », bases du calcul booléen, qui résultent de l'analyse combinatoire des variations des grandeurs d'entrées uniquement.
  • les fonctions logiques « séquentielles » ou bascules, qui résultent de l'association de plusieurs fonctions logiques « combinatoires » synchronisées grâce à une "horloge" qui donne le tempo; les valeurs de sorties dépendent non seulement des valeurs d'entrée, mais aussi de l'instant ou elles sont mesurées (avant ou après la synchronisation par l'horloge).

Les fonctions logiques combinatoires directement issues des mathématiques (algèbre de Boole) sont les outils de base de l'électronique numérique. Elles sont mises en œuvre en électronique sous forme de portes logiques. Ainsi les circuits électroniques calculent des fonctions logiques de l'algèbre de Boole. Ces portes électroniques sont construites à partir de plusieurs transistors connectés de manière adéquate.

Dans d'autres applications, on peut trouver des portes logiques à base de relais, de fluides ou d'éléments optiques ou mécaniques. Selon la modélisation utilisée, on prendra en compte les temps de retard ou pas dans les calculs.

NB: L'automatisme et l'informatique utilisent la logique combinatoire mais surtout la logique séquentielle.

Historique

De la roue dentée à la molécule

Les premières fonctions logiques furent réalisées de manière mécanique. Charles Babbage, vers 1837, conçut la « machine analytique », assemblage de portes reliées à des roues dentées pour effectuer des opérations logiques. Par la suite, les opérations logiques furent effectuées grâce à des relais électromagnétiques.

En 1891, Almon Strowger déposa un brevet pour un appareil contenant un commutateur basé sur une porte logique ((en) Brevet U.S. 0447918). Son brevet ne fut guère exploité jusque dans les années 1920. À partir de 1898, Nikola Tesla déposa une série de brevets concernant des appareils basés sur des circuits à portes logiques. Finalement, les tubes à vides remplacèrent les relais pour les opérations logiques. En 1907, Lee De Forest modifia l'un de ces tubes et l'utilisa comme une porte logique ET. Claude E. Shannon introduisit l'utilisation de l'algèbre de Boole dans la conception de circuits en 1937. Walther Bothe, inventeur du circuit de coïncidence, reçut le prix Nobel de physique en 1954, pour la création de la première porte logique ET électronique moderne en 1924. Des travaux de recherche sont actuellement menés pour la génération de portes logiques moléculaires.

Les portes logiques à transistors

La forme la plus simple de la logique électronique est la logique à diodes. Cela permet la fabrication de portes ET et OU, mais pas de portes NON ce qui conduit à une logique incomplète. Pour créer un système logique complet, il est nécessaire d'utiliser des lampes ou des transistors.

La famille la plus simple de portes logiques utilisant des transistors bipolaires est appelée résistance-transistor ou RTL (resistor-transistor logic). Au contraire des portes à diodes, les portes RTL peuvent être mises en cascade indéfiniment pour produire des fonctions logiques complexes. Pour diminuer le temps de retard, les résistances utilisées par les portes RTL furent remplacées par des diodes, ce qui donna naissance aux portes logiques diode-transistor ou DTL (diode-transistor logic). On découvrit ensuite qu'un transistor pouvait faire le travail de deux diodes en prenant la place d'une seule, ce qui mena à la création de portes logiques transistor-transistor ou TTL (transistor-transistor logic). Dans certains types de circuits, les transistors bipolaires furent remplacés par des transistors à effet de champ (MOSFET) ce qui donna naissance à la logique CMOS.

Circuit intégré 7400 contenant 4 portes NON-ET (NAND). Les deux autres broches servent à l'alimentation 0V / 5V.

Les concepteurs de circuits logiques utilisent actuellement des circuits intégrés préfabriqués, notamment en TTL, la série 7400 de Texas Instruments, et en CMOS, la série 4000 de RCA, ainsi que leurs dérivés plus récents. La plupart de ces circuits contiennent des transistors à plusieurs émetteurs, utilisés pour implémenter la fonction ET, et qui ne sont pas disponibles séparément. De plus en plus, ces circuits logiques fixes sont remplacés par des circuits programmables, qui permettent aux concepteurs d'intégrer un grand nombre de portes logiques diverses dans un seul circuit intégré. La nature programmable de ces circuits, parmi lesquels les FPGA, a enlevé au hardware son aspect "dur" : il est désormais possible de changer les fonctions logiques d'un système en reprogrammant certains de ses composants, ce qui permet de modifier les caractéristiques d'un circuit logique hardware.

Les portes logiques électroniques diffèrent de manière significative de leurs équivalents à relais et contacts. Elles sont bien plus rapides, moins gourmandes et beaucoup plus petites (au moins un million de fois dans la plupart des cas). De plus, il y a une différence fondamentale dans la structure. Les circuits à contacts créent un chemin continu, dans lequel le courant peut circuler dans les deux directions entre l'entrée et la sortie. La porte logique à semi-conducteurs, au contraire, agit comme un puissant amplificateur de tension, qui reçoit un courant faible en entrée et produit une tension de basse impédance en sortie. Le courant ne peut pas circuler entre la sortie et l'entrée d'une porte à semi-conducteurs.

Un autre grand avantage des circuits logiques standardisés est qu'ils peuvent être mis en cascade. Autrement dit, la sortie d'une porte peut être reliée aux entrées d'une ou plusieurs portes, et ainsi de suite à l'infini, ce qui permet de construire des circuits d'une complexité quelconque sans avoir besoin de connaître le fonctionnement interne des portes. Dans la pratique, la sortie d'une porte ne peut être connectée qu'à un nombre fini d'entrées, mais cette limite est rarement atteinte dans les nouveaux circuits CMOS comparé aux circuits TTL. Il existe également un délai nommé temps de propagation entre la modification d'une entrée et la modification correspondante en sortie. Dans des portes en cascade, le temps de propagation total est à peu près égal à la somme des temps de propagation individuels, ce qui peut poser problème dans les circuits à grande vitesse.

Portes logiques à 3 états

Les portes logiques dites « à trois états » possèdent une sortie qui peut prendre trois états différents : haut, bas comme sur tout autre circuit logique et un troisième état haute impédance nommé Z. L'état de haute impédance ne joue aucun rôle dans la logique proprement dite qui demeure binaire, mais il équivaut en fait à un circuit ouvert, ou à une « absence » de sortie. Cet état permet de ne pas "polluer" la valeur circulant sur le bus de données auquel il est connecté, lorsque ce circuit ne doit pas en changer l’état.

Ces portes sont utilisées dans les bus électroniques pour l'envoi de données ; un groupe de portes à trois états contrôlées par un circuit approprié équivaut à un multiplexeur qui peut être réparti physiquement sur plusieurs appareils ou plusieurs cartes électroniques.

Classification

Niveaux logiques

En algèbre de Boole, une donnée, qu'elle soit en entrée ou en sortie, n'a que deux niveaux possibles. Selon les applications, ces deux niveaux peuvent porter des noms différents : marche / arrêt, haut / bas, un (1) / zéro (0), vrai / faux, positif / négatif, positif / nul, circuit ouvert / circuit fermé, différence de potentiel / pas de différence, oui / non.

Dans le cas de circuits électroniques, les deux niveaux sont représentés par deux niveaux de tension, « haut » et « bas ». Chaque type de circuit possède ses propres niveaux de tension, pour s'assurer de la connectivité entre les entrées et sorties des circuits. Habituellement, deux niveaux bien distincts (ne risquant pas de se chevaucher) sont définis ; la différence entre les deux niveaux varie entre 0,7 V et 28 V (ce dernier dans le cas des relais).

Pour harmoniser la notation, ces deux niveaux seront notés ici 1 et 0.

Fonctions logiques élémentaires

Les portes peuvent être classées suivant leur nombre d'entrées :

  • « portes » sans entrée : VRAI, FAUX ;
  • portes à une entrée : NON (NOT), OUI ;
  • portes à deux entrées : ET (AND), NON-ET (NAND), OU (OR), NON-OU (NOR), OU exclusif (XOR), coïncidence dite aussi NON-OU exclusif ou équivalence (XNOR), implication ;
  • À partir de trois entrées, le nombre de fonctions commence à subir l'influence de l'explosion combinatoire. On note toutefois l'existence de : ET, OU, etc. à plus de deux entrées.

Il est possible de reconstituer les fonctions NON, ET et OU en utilisant uniquement soit la fonction NON-ET, soit la fonction NON-OU. On évoque cette caractéristique sous la notion d'universalité des opérateurs NON-OU et NON-ET (cf. le connecteur binaire d'incompatibilité, appelé aussi barre de Sheffer).

Lorsqu'on associe deux portes logiques compatibles, on peut connecter deux entrées ensemble, ou une entrée sur une sortie. Il ne faut en aucun cas connecter deux sorties différentes car elles peuvent produire des données différentes ; dans le cas de portes électroniques, cela équivaudrait à un court-circuit.

Représentation

Pour définir chacune des fonctions logiques, nous donnerons plusieurs représentations :

  • une représentation algébrique : équation ;
  • une représentation arithmétique : table de vérité ;
  • une représentation graphique : symbole logique.

Dans le cas de portes électroniques, un niveau logique est représenté par un voltage défini (selon le type de composant utilisé). Chaque porte logique doit donc être alimentée pour délivrer la tension de sortie appropriée. Dans la représentation en symboles logiques, cette alimentation n'est pas représentée, mais elle doit l'être dans un schéma électronique complet.

La représentation d'un système combinatoire incluant plusieurs fonctions logiques peut aussi se faire grâce à un schéma à contact, une équation, une table de vérité et un schéma graphique. Dans ce dernier cas on parlera d'un logigramme.

Représentation graphique

Deux ensembles de symboles sont utilisés pour représenter les fonctions logiques ; les deux sont définis par la norme ANSI/IEEE 91-1984 et son supplément 91a-1991. La représentation par « symboles distinctifs », basée sur les schématisations classiques, est utilisée pour les schémas simples et est plus facile à tracer à la main. Elle est parfois qualifiée de « militaire », ce qui reflète ses origines, sinon son usage actuel.

La représentation « rectangulaire » se base sur la norme CEI 60617-12 ; toutes les portes y sont représentées avec des bords rectangulaires et un symbole, ce qui permet la représentation d'un plus grand nombre de types de circuits. Ce système a été repris par d'autres standards comme EN 60617-12:1999 en Europe et BS EN 60617-12:1999 au Royaume-Uni.

Symboles et tables de vérités de portes logiques

Type

Symbole américain

Symbole européen

Opération booléenne entre A et B

Table de vérité

ET

ET

ET

Entrée |  | Sortie
A | B | A ET B
0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

OU

OU

OU

Entrée |  | Sortie
A | B | A OU B
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

NON

NON

NON

Entrée | Sortie
A | NON A
0 | 1
1 | 0

En électronique, une porte NON est plus communément appelée inverseur. Le cercle utilisé sur la représentation est appelé « bulle », et on l'utilise généralement dans les diagrammes pour montrer qu'une entrée ou une sortie est inversée.

NON-ET (NAND)

NAND

NAND

Entrée |  | Sortie
A | B | A NAND B
0 | 0 | 1
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

NON-OU (NOR)

NOR

NOR

Entrée |  | Sortie
A | B | A NOR B
0 | 0 | 1
0 | 1 | 0
1 | 0 | 0
1 | 1 | 0

OU exclusif (XOR)

XOR

XOR

Entrée |  | Sortie
A | B | A XOR B
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

NON-OU exclusif ou OU-exclusif complémenté (XNOR) ou Identité

XNOR

XNOR

Entrée |  | Sortie
A | B | A XNOR B
0 | 0 | 1
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

Une porte NON-ET (NAND) peut également être représentée en utilisant le symbole OU avec des bulles (inverseurs) sur les entrées, et une porte NON-OU (NOR) peut être représentée par un symbole ET avec des bulles sur les entrées. Cela reflète les lois d'équivalence de De Morgan ; cela permet de rendre également un diagramme plus lisible, ou de fabriquer un circuit facilement avec des portes préfabriquées, car un circuit qui a des bulles des deux côtés peut être remplacé par un circuit non-inversé en changeant la porte. Si une porte NON-ET est représentée par un OU avec des entrées inversées, ou qu'un NON-OU est représenté par un ET avec des entrées inversées, le remplacement se fait automatiquement dans le schéma (les bulles « s'annulent »). C'est courant dans les diagrammes logiques réels — si bien que le lecteur ne doit pas s'habituer à associer les symboles aux portes OU et ET automatiquement, mais doit aussi prendre en compte les inverseurs pour déterminer la bonne fonction représentée. Les entrées inversées sont particulièrement utiles dans le cas de signaux « actifs à l'état bas ».

Les deux autres portes fréquemment rencontrées sont la fonction OU exclusif et son inverse. Un OU exclusif à deux entrées ne renvoie un 1 que quand les deux entrées sont différentes, et un 0 quand elles sont égales, quelle que soit leur valeur. S'il y a plus de deux entrées, la porte renvoie 1 si le nombre d'entrées égales à 1 est impair ([1]). Dans la pratique, ces portes sont souvent réalisées à partir de combinaisons de portes logiques plus simples.

Convention d'écriture

La notation surlignée est vite malcommode. On la remplace souvent par la notation " ' " et si nécessaire un parenthésage. Ainsi :

  • NON(x) = x', d'où (x')' = x.
  • NON·ET(x, y)= (x·y)' = x'+y'.
  • NON·OU(x, y)= (x+y)' = x'·y'.
  • NON·ET(NON·ET(a, b, c), NON·ET(d, f)) = ((a·b·c)')'+((d·f)')' = a·b·c + d·f.
  • NON·OU(NON·OU(a, b, c), NON·OU(d, f)) = ((a+b+c)')'·((d+f)')' = (a+b+c)·(d+f)

Les opérateurs physiques NON·ET/NON·OU étant peu commodes dans les calculs, les deux dernières relations (dites de double couche) facilitent la liaison entre calcul et dessin ; ainsi :

  • une double couche NON·ET réalise toute fonction donnée sous forme d'une somme de monômes booléens ;
  • de même, une double couche NON·OU réalise toute fonction donnée sous forme d'un produit de clauses booléennes.

Autres fonctions logiques

Multiplexeurs

Soient 8 entrées binaires x0 à x7, et 3 entrées de commande a, b, c, permettant d'afficher un nombre de 0 à 7. Un multiplexeur aligne sa sortie s sur l'entrée dont le numéro est affiché. Pour cela, s = a'·b'·c'·x0 + a'·b'·c·x1 + a'·b·c'·x2 + a'·b·c·x3 +....+ a·b·c·x7.

Commande |  |  | Sortie
a | b | c | s
0 | 0 | 0 | x0
0 | 0 | 1 | x1
0 | 1 | 0 | x2
0 | 1 | 1 | x3
* | * | * | *
1 | 1 | 0 | x6
1 | 1 | 1 | x7

Additionneurs

C'est l'exemple type de cellules logiques, regroupements de fonctions des mêmes variables, utilisables comme briques ou boîtes noires dans des ensembles complexes.

simple

Soient a et b deux bits à additionner ; le résultat est un couple (r, s) tel que, arithmétiquement a + b = 2r + s. En termes booléens, r = a·b et s = [image].

complet

L'addition de deux bits a et b sera le plus souvent une addition intermédiaire recevant un report r. Le résultat est alors un couple (R, S) tel que, arithmétiquement, a+b+r = 2R+S. En termes booléens, S = [image] et R = MAJ(a, b, r), où la porte MAJ(orité) a pour définition MAJ(x, y, z)= xy + yz + xz.

soustracteur

Un additionneur complet peut devenir additionneur/soustracteur en complément à un ou complément à deux s'il fait la somme des bits a, [image] et r, où r est un report, et $ une commande valant 0 pour une addition et 1 pour une soustraction. Alors, le résultat est un couple (R, S) où S = [image] et R = MAJ(a, [image], r).

multiplicateur

Un additionneur complet peut devenir une cellule de multiplicateur s'il fait la somme des bits a, b·m et r, où a est un bit d'une somme partielle de produits, b un bit du multiplicande, m un bit du multiplicateur, et r un report. Alors S = [image] · [image] et R = MAJ(a, b·m, r).

Unités de stockage

Au-delà fonctions logiques purement combinatoires, se pose le problème du stockage d'un bit d'information. Les portes logiques présentées plus haut ne stockent pas de données : quand une entrée change, la sortie réagit immédiatement (au temps de propagation près). Il est possible de créer des éléments de stockage soit avec des condensateurs, soit en utilisant le feedback. En connectant la sortie d'une porte à son entrée, on renvoie la sortie dans le circuit logique ; elle peut ainsi être conservée ou modifiée en utilisant les autres entrées. En connectant des portes de cette manière, on crée un verrou (latch en anglais). D'autres circuits un peu plus complexes utilisent des signaux d'horloge (des signaux qui oscillent à une fréquence connue) et changent quand le signal d'horloge passe à 1 ; on les appelle des bascules ou bistables (flip-flops en anglais). En combinant plusieurs bascules en parallèle pour stocker une valeur de plusieurs bits, on crée un registre.

Les registres et autres circuits de stockage sont regroupés sous le terme de « mémoires électroniques ». Leurs performances varient en termes de vitesse, de complexité et de fiabilité de la mémoire. Leurs types peuvent être très différents selon les applications.

Automates à nombre fini d'états

Ils comprennent :

  • un ensemble défini E de variables d'entrée,
  • un ensemble défini I de variables d'état internes, stockées dans un registre,
  • un ensemble défini S de variables de sortie,
  • un réseau combinatoire T : (E, I) → I assurant l'évolution de l'automate en fonction des entrées successives,
  • un réseau combinatoire R : (E, I) → S assurant la définition de la sortie, conformément aux entrées actuelles, et à la mémoire que I a gardé des situations antérieures.

Dès lors que toutes les variables se présentent sous forme binaire, ils sont réalisables à l'aide de circuits logiques.

Ils peuvent être simples, ou fédérés en automates plus complexes.

Unités fonctionnelles

Les circuits logiques peuvent également réaliser des éléments comme des multiplexeurs, des unités arithmétiques et logiques (en anglais : Arithmetic and Logic Unit ou ALU), des mémoires, ou les automates animant un processeur. Les microprocesseurs rassemblent de tels éléments, et peuvent contenir plus de 100 millions de portes logiques.

Les composants de microprocesseurs sont à base de transistors à effet de champ, en particulier des MOSFET.

Notes et références

  • (en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « Logic gate » (voir la liste des auteurs)

Voir aussi

Sur les autres projets Wikimedia :

· Fonctions logiques, sur Wikimedia Commons

· Électronique numérique : logique, sur Wikibooks

Articles connexes

  • Bascule
  • Algèbre de Boole (logique)
  • Sortance
  • Table de Karnaugh
  • Logique pneumatique
  • Connecteur logique


Système binaire — Wikipédia

Système binaire

Exemple d'informations binaires 01011010110000010101101011000001010110101100000100001010110101100000101010000101011010110000010101

Le système binaire est un système de numération utilisant la base 2. On nomme couramment bit (de l'anglais binary digit, soit « chiffre binaire ») les chiffres de la numération binaire positionnelle.

Ceux-ci ne peuvent prendre que deux valeurs, notées par convention 0 et 1.

C'est un concept essentiel de l'informatique. En effet, les processeurs des ordinateurs actuels sont composés de transistors ne gérant chacun que deux états.

Un calcul informatique n'est donc qu'une suite d'opérations sur des paquets de 0 et de 1, appelés octets lorsqu'ils sont regroupés par huit.

Définition

Le système binaire le plus courant est l'équivalent en base deux de la numération de position que nous utilisons en base dix dans la vie courante.

Dans ce type de codage, chaque nombre est représenté de façon unique par une suite ordonnée de chiffres. Et chaque chiffre représente une puissance de la base. Si on se limite dans un premier temps aux nombres entiers positifs, en base dix ces puissances sont : un (1), dix (représenté par 10), cent (dix fois dix, représenté par 100), mille (dix fois cent, représenté par 1000), dix mille etc. En base deux, ces puissances sont : un (1), deux (représenté lui aussi par 10), quatre (deux fois deux, représenté par 100), huit (deux fois quatre, représenté par 1000), seize (deux fois huit, représenté par 10000) etc.

On voit que la signification des représentations 10, 100, 1000, etc. dépend de la base utilisée : 10 est toujours égale à la base, c'est-à-dire dix en base dix, mais deux en base deux[1]

En base dix, on a besoin de dix chiffres, de zéro à neuf ; en base n, on a besoin de n chiffres, de zéro à n-1 ; et donc en base deux, on a besoin de deux chiffres : zéro et un.

Un nombre qui s'exprime en base B par les quatre chiffres 1101 s'analyse :
, qui donne :

1101 en base B = 10 :

1101 en base B = 8 :

1101 en base B = 2 :

Énumération des premiers nombres

Les premiers nombres, et chiffres de la base de numération 10, s'écrivent :

décimal | binaire | commentaire
0 | 0 | Zéro
1 | 1 | un = base puissance zéro (valable pour toutes les bases, donc deux et dix)
2 | 10 | deux = deux puissance un (un zéro derrière le 1)
3 | 11 |
4 | 100 | quatre = deux puissance deux (deux zéro derrière le 1)
5 | 101 |
6 | 110 |
7 | 111 |
8 | 1000 | huit = deux puissance trois (trois zéro derrière le 1)
9 | 1001 |

Opérations

Les techniques des quatre opérations de base (addition, soustraction, multiplication et division) restent exactement les mêmes qu'en notation décimale, elles sont juste simplifiées de façon drastique parce qu'il n'y a que deux chiffres (zéro et un). Pour la multiplication par exemple, quelle que soit la base, la multiplication par 10 (c’est-à-dire par la base elle-même)[2] se fait en ajoutant un zéro à droite.

Seules changent d'une part la forme de la suite de chiffres qui exprime le résultat (elle ne compte que des zéros et un), d'autre part la signification de cette suite (10 signifie « deux » et non « dix », 100 signifie « quatre » et non « cent », etc.).

exemples : additions, soustractions

On passe d'un nombre binaire au suivant en ajoutant 1, comme en décimal, sans oublier les retenues et en utilisant la table ordinaire (mais réduite à sa plus simple expression) :

 0+0=0    0+1=1    1+0=1   1+1=0 avec 1 retenue
 0-0=0    0-1=1 avec 1 retenue   1-0=1   1-1=0

ainsi:

   11
+   1
 ____
  100

Détail :

1 + 1 = 10           => on pose 0 et on retient 1
1 + 1(retenue) = 10  => on pose 0 et on retient 1
0 + 1(retenue) = 1   => on pose 1 devant 00

Théorie informatique

L'arithmétique binaire (plus simplement le calcul binaire) est utilisé par les systèmes électroniques les plus courants (calculatrices, ordinateurs, etc.) car les deux chiffres 0 et 1 s'y traduisent facilement par la tension ou le passage d'un courant : 0 représentant l'état bas (tension ou courant nul) et 1 l'état haut (tension qui existe, courant qui passe).

Représentation des entiers négatifs

Pour compléter la représentation des entiers, il faut pouvoir écrire des entiers négatifs. La façon informatique de le faire est prévoir un bit de signe, placé en tête. Un bit de signe nul indique une valeur positive, un bit de signe positionné à 1 indique une valeur négative.

Les informaticiens utilisent deux représentations.

Complément à un

Ce codage, fort simple, consiste à inverser la valeur de chaque bit composant une valeur binaire. Par exemple, pour obtenir -7 :

0111 valeur décimale 7

1000 complément à un

Dans ce système, la valeur 0 a deux représentations : « +0 » et « -0 » (dans notre exemple : 0000 et 1111), ce qui oblige à réaliser 2 tests pour tester la valeur nulle d'un résultat.

Complément à deux

Afin de pallier ce défaut, on a introduit la représentation par complément à deux. Celle-ci consiste à réaliser un complément à un de la valeur, puis d'ajouter 1 au résultat.

Par exemple pour obtenir -7:

0111 codage de 7 en binaire
1000 complément à un
1001 on ajoute 1 : représentation de -7 en complément à deux

Le zéro est représenté seulement par 0000

Ce codage a l'avantage de ne pas nécessiter de différenciation spéciale des nombres positifs et négatifs, et évite en particulier le problème d'ordinateurs anciens (Control Data 6600) qui avaient un « +0 » et un « -0 » dont il fallait faire comprendre aux circuits de tests que c'était le même nombre ! Voici une addition de -7 et +9 réalisée en complément à deux sur 4 bits :

-7        1001
+9        1001
__        ____
 2    (1) 0010     (on 'ignore' la retenue)

Avec n bits, ce système permet de représenter les nombres entre -2n-1 et 2n-1-1.

Entre les bases 2, 8 et 16

Du binaire vers octal ou hexadécimal]

Les bases 8 (octale) et 16 (hexadécimale) sont des bases multiples de la base 2. Ces deux bases ont été couramment employées en informatique et pour des raisons pratiques; ces bases étant fortement liées à la base 2 et les nombres écrits dans ces bases étant plus « manipulables » (car d'écriture plus courte) par l'intellect humain. L'écriture de nombres dans ces bases est facilement obtenue par regroupement de chiffres de l'écriture du nombre en base 2.

  • Octal : base 8 avec 8 = 2^3. Il suffit de parcourir le nombre binaire de la droite vers la gauche en regroupant les chiffres binaires 3 par 3 : chaque paquet de 3 (le dernier devant être parfois complété par des 0 à gauche) est l'écriture binaire d'un chiffre en base 8 (08=000, 18=001, 28=010, 38=011, 48=100, 58=101, 68=110, 78=111).
    • 101011011102 va s'écrire 10 101 101 110 et en convertissant la valeur de chacun des blocs en un chiffre octal, on obtient le nombre octal 25568.
  • Hexadécimal : base 16 avec 16 = 2^4. Il suffit de parcourir le nombre binaire de la droite vers la gauche en regroupant les chiffres binaires par 4 par 4 : chaque paquet de 4 bits est la représentation binaire d'un chiffre en base 16. En base 16, il faut 16 symboles et conventionnellement, on utilise les 10 chiffres décimaux suivis des 6 premiers caractères de l'alphabet selon la règle suivante: A16=1010=10102, B16=1110=10112, C16=1210=11002, D16=1310=11012, E16=1410=11102 et F16=1510=11112.
    • 101011011102 va s'écrire 101 0110 1110 et en convertissant la valeur de chacun des blocs en décimal on obtient : 5, 6, 14 c'est-à-dire 56E16.

On pourrait facilement étendre ce principe à toutes les bases qui sont puissances de 2.

Vers le binaire

Il suffit de convertir la valeur de chacun des chiffres sous leur forme binaire.

  • 1A2F16 va s'écrire 1, 10=8+2, 2, 15=8+4+2+1 soit 0001 1010 0010 11112
  • 1568 va s'écrire 1, 5=4+1, 6=4+2 soit 1 101 1102

Table des valeurs des groupements de chiffres binaires

Binaire | Décimal | Octal | Hexadécimal
0000 | 0 | 0 | 0
0001 | 1 | 1 | 1
0010 | 2 | 2 | 2
0011 | 3 | 3 | 3
0100 | 4 | 4 | 4
0101 | 5 | 5 | 5
0110 | 6 | 6 | 6
0111 | 7 | 7 | 7

Binaire | Décimal | Octal | Hexadécimal
1000 | 8 | 10 | 8
1001 | 9 | 11 | 9
1010 | 10 | 12 | A
1011 | 11 | 13 | B
1100 | 12 | 14 | C
1101 | 13 | 15 | D
1110 | 14 | 16 | E
1111 | 15 | 17 | F

Code de Gray ou binaire réfléchi

Article détaillé : code de Gray.

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue !

Ce codage permet de ne faire changer qu'un seul bit à la fois quand un nombre est incrémenté ou décrémenté d'une unité.

Le code de Gray, également appelé binaire réfléchi, permet de ne faire changer qu'un seul bit à la fois quand un nombre est incrémenté ou décrémenté d'une unité. Le nom du code vient de l'ingénieur américain Frank Gray qui déposa un brevet sur ce code en 1947[3]. Monsieur Louis Gros publia, à Lyon, en 1872 un opuscule, Théorie du Baguenaudier, par un clerc de notaire lyonnais où ce code était présenté pour la première fois en lien avec un casse-tête[4]. Monsieur Gros fut clerc de notaire puis Conseiller à la Cour d'Appel de Lyon.

codage binaire classique |  | Codage Gray ou binaire réfléchi
0 | 0000 | 0 | 0000
1 | 0001 | 1 | 0001
2 | 0010 | 2 | 0011
3 | 0011 | 3 | 0010
4 | 0100 | 4 | 0110
5 | 0101 | 5 | 0111
6 | 0110 | 6 | 0101
7 | 0111 | 7 | 0100

Pour « calculer » directement le code de Gray d'un entier à partir de celui de son prédécesseur on peut procéder ainsi :

  • lorsqu'il y a un nombre pair de 1 on inverse le dernier bit
  • lorsqu'il y a un nombre impair de 1 on inverse le bit directement à gauche du 1 le plus à droite.

Le code de Gray est utilisé entre autres sur une roue codeuse.

Décimal codé binaire (« binary coded decimal », ou BCD)

Afin de concilier la logique binaire de l'ordinateur avec la logique humaine, on peut convertir en binaire, plutôt que les nombres eux-mêmes, chacun des chiffres qui les composent en notation décimale positionnelle. Chacun de ces chiffres est alors codé 4 bits :

1994 =  0001    1001   1001   0100
      1×1000 + 9×100 + 9×10 + 4×1

Avec n bits (n multiple de 4), il est possible de représenter les nombres entre 0 et 10n/4-1. Soit approximativement entre 0 et 1.778n-1. Le BCD est un code redondant, en effet certaines combinaisons ne sont pas utilisées (comme 1111 par exemple).

Cette représentation évite par construction tous les problèmes gênants de cumul d'arrondi qui interviendraient lors de la manipulation de grands nombres dépassant la taille des circuits en arithmétique entière et obligent à recourir au flottant. Il est cependant possible de manipuler des nombres à précision arbitraire en utilisant un codage plus efficace que le BCD.

Il existe des variantes du codage BCD :

  • code Aiken où 0, 1, 2, 3, 4 sont codés comme en BCD et 5, 6, 7, 8, 9 sont codés de 1011 à 1111. Il permet d'obtenir le complément à 9 en permutant les 1 et les 0.
  • codage binaire excédant 3 qui consiste à représenter le chiffre à coder + 3.

Article détaillé : Binary coded decimal.

Applications

Théorie de l'information

En théorie de l'information, l'entropie d'une source d'information est exprimée en bits. La théorie elle-même est indifférente à la représentation des grandeurs qu'elle utilise.

Logique

La logique classique est une logique bivalente: une proposition est soit vraie, soit fausse. Il est donc possible de représenter la vérité d'une proposition par un chiffre binaire. On peut par exemple modéliser les opérations de l'arithmétique binaire à l'aide de l'algèbre de Boole.

L'algèbre de Boole représente un cas très particulier d'usage des probabilités ne faisant intervenir que les seules valeurs de vérité 0 et 1. Voir Théorème de Cox-Jaynes.

Informatique

Le binaire est utilisé en informatique car il permet de modéliser le fonctionnement des composants de commutation comme le TTL ou le CMOS. La présence d'un seuil de tension aux bornes des transistors, en négligeant la valeur exacte de cette tension, représentera 0 ou 1. Par exemple le chiffre 0 sera utilisé pour signifier une absence de tension à 0,5V près, et le chiffre 1 pour signifier sa présence à plus de 0,5V. Cette marge de tolérance permet de pousser les cadences des microprocesseurs à des valeurs atteignant sans problème (hormis d'échauffement) plusieurs gigahertz.

En informatique, la représentation binaire permet de clairement manipuler des bits : chaque chiffre binaire correspond à un bit. Cependant, la représentation binaire nécessitant l'usage de beaucoup de chiffres (même pour des nombres assez petits), elle entraîne d'importants problèmes de lisibilité et donc de risques d'erreur de transcription pour les programmeurs. On préfère donc d'autres représentations : la notation hexadécimale, qui permet de manipuler l'information par paquets de 4 bits, est adaptée à la quasi-totalité des microprocesseurs actuels travaillant avec des mots de 8, 16, 32 ou 64 bits ; plus rare, la notation octale, populaire du temps des premiers mini-ordinateurs DEC à 12 ou 36 bits, qui permet de représenter l'information par paquets de 3 bits.

· 63 (10) = 111111 (2) = 77 (8) = 3F (16)

· 64 (10) = 1000000 (2) = 100 (8) = 40 (16)

· 255 (10) = 11111111 (2) = 377 (8) = FF (16)

· 256 (10) = 100000000 (2) = 400 (8) = 100 (16)


Système hexadécimal — Wikipédia

Système hexadécimal

Un article de Wikipédia, l'encyclopédie libre.

0hex | = | 0dec | = | 0oct | 0 | 0 | 0 | 0
1hex | = | 1dec | = | 1oct | 0 | 0 | 0 | 1
2hex | = | 2dec | = | 2oct | 0 | 0 | 1 | 0
3hex | = | 3dec | = | 3oct | 0 | 0 | 1 | 1
4hex | = | 4dec | = | 4oct | 0 | 1 | 0 | 0
5hex | = | 5dec | = | 5oct | 0 | 1 | 0 | 1
6hex | = | 6dec | = | 6oct | 0 | 1 | 1 | 0
7hex | = | 7dec | = | 7oct | 0 | 1 | 1 | 1
8hex | = | 8dec | = | 10oct | 1 | 0 | 0 | 0
9hex | = | 9dec | = | 11oct | 1 | 0 | 0 | 1
Ahex | = | 10dec | = | 12oct | 1 | 0 | 1 | 0
Bhex | = | 11dec | = | 13oct | 1 | 0 | 1 | 1
Chex | = | 12dec | = | 14oct | 1 | 1 | 0 | 0
Dhex | = | 13dec | = | 15oct | 1 | 1 | 0 | 1
Ehex | = | 14dec | = | 16oct | 1 | 1 | 1 | 0
Fhex | = | 15dec | = | 17oct | 1 | 1 | 1 | 1

Le système hexadécimal est un système de numération positionnel en base 16. Il utilise ainsi 16 symboles, en général les chiffres arabes pour les dix premiers chiffres et les lettres A à F pour les six suivants.

Le système hexadécimal est utilisé notamment en électronique numérique et en informatique car il est particulièrement commode et permet un compromis entre le code binaire des machines et une base de numération pratique à utiliser pour les ingénieurs. En effet, chaque chiffre hexadécimal correspond exactement à quatre chiffres binaires (ou bits), rendant les conversions très simples et fournissant une écriture plus compacte. L'hexadécimal a été utilisé la première fois en 1956 par les ingénieurs de l'ordinateur Bendix G-15.

Sommaire

  • 1 Étymologie
  • 2 Écriture des entiers
  • 3 Utilisation, avantages et inconvénients
  • 4 Conversion
  • 5 Notation
  • 6 Système bibi-binaire
  • 7 Codage des couleurs
  • 8 Notes et références
  • 9 Voir aussi

Étymologie

L'adjectif hexadécimal provient de la juxtaposition de hexa et de décimal. Le préfixe hexa provient du grec ἕξ (hex) qui signifie six alors que décimal est un terme de provenance latine. Le choix a été fait dans l'appellation d'écrire 6+10 au lieu de 16, pour insister sur l'ajout de six chiffres supplémentaires par rapport au système décimal, système largement diffusé aux États-Unis.

Pour obtenir une cohérence dans l'étymologie tout en conservant l'écriture 6+10, la documentation Bendix utilisait l'appellation sexadécimal ; mais l'appellation fut rejetée, jugée trop risquée. Selon Schwartzman[1], les pirates informatiques auraient été tentés d'utiliser l'abréviation sex. Selon Knuth [2] la bonne appellation aurait dû être senidenary ou en français système sénidénaire, dont la construction étymologique est la même que système binaire.

Écriture des entiers

Le système hexadécimal nécessite l'introduction de 16 chiffres, représentant les 16 premiers entiers naturels :

0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ; A ; B ; C ; D ; E ; F.

Un entier est écrit comme la concaténation de ces chiffres, et sa lecture s'effectue de droite à gauche. Sa valeur vaut la somme des chiffres affectés de poids correspondant aux puissances successives du nombre 16. Par exemple, 4D516 vaut 5 * 160 + 13 * 161 + 4 * 16 2 = 123710.

L'addition s'effectue à partir de la technique de l'addition et de la table d'addition suivante :

+ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F
0 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F
1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10
2 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11
3 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12
4 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13
5 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14
6 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15
7 | 7 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16
8 | 8 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17
9 | 9 | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18
A | A | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19
B | B | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A
C | C | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A | 1B
D | D | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A | 1B | 1C
E | E | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A | 1B | 1C | 1D
F | F | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A | 1B | 1C | 1D | 1E

La multiplication s'effectue à partir de la technique de la multiplication par glissement par jalousies et en utilisant la table de multiplication suivante :

x | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0
1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F
2 | 0 | 2 | 4 | 6 | 8 | A | C | E | 10 | 12 | 14 | 16 | 18 | 1A | 1C | 1E
3 | 0 | 3 | 6 | 9 | C | F | 12 | 15 | 18 | 1B | 1E | 21 | 24 | 27 | 2A | 2D
4 | 0 | 4 | 8 | C | 10 | 14 | 18 | 1C | 20 | 24 | 28 | 2C | 30 | 34 | 38 | 3C
5 | 0 | 5 | A | F | 14 | 19 | 1E | 23 | 28 | 2D | 32 | 37 | 3C | 41 | 46 | 4B
6 | 0 | 6 | C | 12 | 18 | 1E | 24 | 2A | 30 | 36 | 3C | 42 | 48 | 4E | 54 | 5A
7 | 0 | 7 | E | 15 | 1C | 23 | 2A | 31 | 38 | 3F | 46 | 4D | 54 | 5B | 62 | 69
8 | 0 | 8 | 10 | 18 | 20 | 28 | 30 | 38 | 40 | 48 | 50 | 58 | 60 | 68 | 70 | 78
9 | 0 | 9 | 12 | 1B | 24 | 2D | 36 | 3F | 48 | 51 | 5A | 63 | 6C | 75 | 7E | 87
A | 0 | A | 14 | 1E | 28 | 32 | 3C | 46 | 50 | 5A | 64 | 6E | 78 | 82 | 8C | 96
B | 0 | B | 16 | 21 | 2C | 37 | 42 | 4D | 58 | 63 | 6E | 79 | 84 | 8F | 9A | A5
C | 0 | C | 18 | 24 | 30 | 3C | 48 | 54 | 60 | 6C | 78 | 84 | 90 | 9C | A8 | B4
D | 0 | D | 1A | 27 | 34 | 41 | 4E | 5B | 68 | 75 | 82 | 8F | 9C | A9 | B6 | C3
E | 0 | E | 1C | 2A | 38 | 46 | 54 | 62 | 70 | 7E | 8C | 9A | A8 | B6 | C4 | D2
F | 0 | F | 1E | 2D | 3C | 4B | 5A | 69 | 78 | 87 | 96 | A5 | B4 | C3 | D2 | E1

Utilisation, avantages et inconvénients

Ce format est largement utilisé en informatique car il offre une conversion facile avec le système binaire, système employé par les ordinateurs.

Il est en effet possible de traduire du binaire vers de l'hexadécimal et réciproquement, groupe de chiffres par groupe de chiffres. Cette caractéristique s'explique par le fait que 16 (nombre de chiffres dans la base hexadécimale) est lui-même une puissance de 2 (nombre de chiffres de la base binaire), et donc que la quantité d'information d'un chiffre hexadécimal vérifie :

Cette égalité revient à dire que : « À un chiffre dans la base 16, correspondent exactement quatre chiffres dans la base 2. »

Cette facilité de conversion a conduit la notation hexadécimale à être utilisée pour noter des nombres initialement quantifiés ou à destination d'être quantifiés en binaire, l'hexadécimal étant plus compact (quatre fois moins de chiffres) et offrant une meilleure lisibilité pour l'œil humain.

Un avantage supplémentaire de la base 16 est sa concordance avec l'octet, mot de 8 bits auquel correspond aujourd'hui fréquemment un byte, la plus petite unité de stockage adressable. En se basant sur la formule précédente, nous pouvons facilement constater qu'à 8 bits correspondent exactement deux chiffres hexadécimaux :

Il est donc commode de noter la valeur d'un octet sur deux chiffres hexadécimaux.

La table ASCII a été construite de façon à faire commencer les suites de symboles élémentaires (chiffres, lettres minuscule, lettres majuscules) à des positions remarquables lorsqu'elles sont exprimés en binaire, octal ou hexadécimal.

Par exemple, la lettre « A » correspond ainsi au code hexadécimal 41 (40 + la position de la lettre dans l'alphabet), le chiffre « 0 » correspond au code hexadécimal 30 (30 + la valeur du chiffre).

Les conversions entre le système décimal et l'hexadécimal sont moins aisées que les conversions entre le système décimal et le binaire [3].

Conversion

La conversion de binaire en hexadécimal se fait en regroupant les chiffres (les bits) quatre par quatre, ou inversement en remplaçant chaque chiffre hexadécimal par 4 chiffres binaires :

Binaire | 1.0101.1010.1010.1100.1111.0111
regroupé par 4 | 1 | 0101 | 1010 | 1010 | 1100 | 1111 | 0111
regroupé en hexadécimal | 1 | 5 | A | A | C | F | 7
Hexadécimal | 15AACF7
(Décimal) | 22719735

La conversion vers le système décimal est réalisée en effectuant la somme

où n est le nombre de chiffres et où [image] est la valeur du chiffre hexadécimal à la position i.

Ainsi 15AACF7 se convertit en décimal de la façon suivante

1×166 + 5×165 + 10×164 + 10×163 + 12×162 + 15×161 + 7×160 = 22719735.

La conversion du décimal vers l'hexadécimal se fait par une suite de divisions entières ou bien en utilisant le binaire comme base intermédiaire.

Notation

Des notations sont utilisées, notamment dans les langages informatiques, pour différencier sans ambiguïté les chiffres hexadécimaux des autres :

  • notation préfixée : 0x123 (langage C et dérivés), &h123 (BASIC), $123 (en Pascal, et dérivés comme le VHDL en électronique), mais aussi #123 (Common Lisp), 0h123 (Texas Instrument) ou X'123' (COBOL)
  • notation suffixée : 123h, [image] (arithmétique)

Voir aussi nombres hexadécimaux dans l'article Wikipédia:Conventions typographiques.

Système bibi-binaire

Le chanteur et humoriste Boby Lapointe avait inventé en 1968 un système hexadécimal, appelé système bibi-binaire à la fois drôle et cohérent.

Codage des couleurs

Le système hexadécimal est un des modes de codage informatique des couleurs des écrans d'ordinateurs.

Notes et références

  1. ↑ (en) Steven Schwartzman, The Words of Mathematics: An Etymological Dictionary of Mathematical Terms Used in English,‎ 1996 (lire en ligne), p. 105
  2. ↑ (en) Donald Knuth, TAOCP, vol. 2,‎ 1969
  3. ↑ en considérant que le produit par 0 ou 1 d'un terme est plus "aisé" qu'un produit par un facteur compris entre 0 à 15

Voir aussi

  • Base (arithmétique)
  • Système binaire
  • Système de numération
  • Temps hexadécimal
  • John W. Nystrom
  • Éditeur hexadécimal


American Standard Code for Information Interchange

Un article de Wikipédia, l'encyclopédie libre.

La table des caractères ASCII sous une forme condensée qui met en évidence une organisation fondée sur la base 16.

PDF : fr en
 v · d · m
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
000
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
001
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
002
SP
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/
003
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
004
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
005
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
006
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
007
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
DEL

Les 95 caractères ASCII affichables :
 !"#$%&'()*+,-./
0123456789:;<=>?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ[\]^_
`abcdefghijklmno
pqrstuvwxyz{|}~
Cette section doit être recyclée. Une réorganisation et une clarification du contenu sont nécessaires. Discutez des points à améliorer en page de discussion.

L'American Standard Code for Information Interchange (Code américain normalisé pour l'échange d'information), plus connu sous l'acronyme ASCII ([askiː]) est une norme de codage de caractères en informatique ancienne et connue pour son influence incontournable sur les codages de caractères qui lui ont succédé. Elle était la plus largement compatible pour ce qui est des caractères latins non accentués.

ASCII contient les caractères nécessaires pour écrire en anglais. Les caractères accentués sont fournis par d'autres normes, comme aujourd'hui, l'Unicode. Le jeu de caractères codés ASCII est le principal système qui a permis l'échange de textes en anglais à un niveau mondial, limitant ainsi l'usage des langues locales au travers d'extensions régionales.

L'ASCII est une des variantes de l'ISO/CEI 646. Il est inclus dans plusieurs dizaines de normes et standards augmentant les caractères disponibles ou extensions (ASCII étendu) Celles-ci peuvent être régionales (ISO/CEI 8859), nationales (GB 18030) ou internationales (ISO 2022, ISO/CEI 10646 ou Unicode). Avec l'avènement de la mondialisation et de l'internationalisation des systèmes d'information, les limitations de l'ASCII ne sont plus acceptées que dans des domaines très techniques qui requirent la compatibilité avec des protocoles ou systèmes anciens. Malheureusement, l'ASCII n'a donné naissance qu'à des normes de codage incompatibles entre elles.

Dans la norme Unicode, le standard ASCII est défini sous le nom de « C0 Controls and Basic Latin ».

Histoire

Avant la standardisation, de nombreux codages de caractères incompatibles entre eux existaient[1].

En 1960, l'ISO a créé le technical committee on computers and information processing[2]. Il a été divisé en six groupes de travail.

  • Working Group A: Glossary
  • Working Group B: Character Sets and Coding
  • Working Group C: Character Recognition
  • Working Group D: Input and Output Media
  • Working Group E: Programming Languages
  • Working Group F: Digital Data Transmission

L'American Standards Association était chargé du standard des États-Unis.

L'ANSI a reconnu le consortium Business Equipment Manufacturers Association (BEMA, puis, CBEMA) comme le parrain du travail de standardisation du traitement des données. En 1960 BEMA a formé un groupe de traitement des données des partenaires, dont Minneapolis-Honeywell. Ce groupe a formé un Plans and Policies Committee, qui à son tour a formé l'Engineering Committee. L'Engineering Committee a formé le comité X3, qui a été reconnu par l'ASA comme sectional committee.

La liste des caractères à considérer et leur position ont été débattues[3].

Elle a été inventée par l'américain Bob Bemer en 1961.[réf. nécessaire]

En 1961, le DoD met au point un code standard de transmission de donnée sur 8 bits[4]. Ce standard 8 bits est une variante des standards FIELDATA sixbits utilisés dans la décennie précédente par la défense. Il a eu une influence notable sur la première version de l'ASCII.

En 1963, la première version publiée de l'ASCII apparaît.

Auparavant, d'autres standards étaient utilisés notamment sur les cartes perforées[5].

Sa dernière version stabilisée a été normalisée par l’ANSI en 1986 sous la désignation ANSI X3.4:1986 (après deux autres versions en 1967 et 1968, historiquement normalisées par l’ASI, devenu ANSI mais qui ne normalisait pas encore toutes les positions). C’est également la variante américaine des jeux de caractères codés selon la norme ISO/CEI 646 avec laquelle on la confond souvent (d’où sa désignation également comme US-ASCII pour lever l’ambigüité, désignation préférée dans le registre IANA des jeux de caractères codés).

À l'époque elle a été en concurrence avec des standards incompatibles. Par la suite, l'existence de nombreux codages reprenant les conventions de l'ASCII l'a rendu très populaire.

Principes

L'ASCII définit seulement 128 caractères numérotés de 0 à 127 et codés en binaire de 0000000 à 1111111. Sept bits suffisent donc pour représenter un caractère codé en ASCII. Toutefois, les ordinateurs travaillant presque tous sur un multiple de huit bits (multiple d'un octet) depuis les années 1970, chaque caractère d'un texte en ASCII est souvent stocké dans un octet dont le 8e bit est 0. Aujourd'hui encore, certains systèmes de messagerie électronique et de SMS fonctionnent avec des bytes ou multiplet composés de seulement sept bits (contrairement à un octet qui est un byte ou multiplet standardisé à huit bits).

Les caractères de numéro 0 à 31 et le 127 ne sont pas affichables ; ils correspondent à des commandes de contrôle de terminal informatique. Le caractère numéro 127 est la commande pour effacer. Le caractère numéro 32 est l'espace. Les autres caractères sont les chiffres arabes, les lettres latines majuscules et minuscules sans accent et quelques symboles de ponctuation.

L'absence des caractères des langues étrangères à l'anglais rend ce standard insuffisant à lui seul pour des textes étrangers (par exemple en langue française), ce qui rend nécessaire l'utilisation d'autres encodages.

Lorsqu'il est employé seul pour la langue anglaise, il interdit l'usage des accents dans la langue anglaise (cf wikt:en:Appendix:English words with diacritics).

Limitations

Quelques-uns des caractères graphiques ASCII ont provoqué une polysémie. Ceci est en tout ou partie lié au nombre limité de codets dans un jeu à sept bits. Ceci se retrouve notamment dans les symboles de ponctuation et l'utilisation des guillemets. L'ASCII a été conservé parce qu'il est omniprésent dans de nombreux logiciels. Cet héritage se retrouve dans Unicode ou ces signes sont dans un bloc disjoint des autres symboles similaires, se trouvant pour la plupart codés à partir de U+2000[6].

Internationalisation

Les limites du standard américain ASCII ont conduit, sur trois périodes différentes, à trois approches de l'internationalisation :

  • L'utilisation de standards régionaux à caractères-monooctets, techniquement les plus faciles à mettre en place ;
  • L'utilisation de standards extensibles, où un même octet peut représenter un caractère différent suivant le contexte (famille ISO 2022) ainsi que des extensions où un caractère est codé sur plusieurs octets ;
  • L'utilisation du Standard Unicode (famille UTF), qui est celui qui comprend le plus grand nombre de caractères.

Les standards régionaux ont l'inconvénient de ne permettre la représentation que d'un ensemble réduit de caractères, comme les caractères d'Europe occidentale. Avec cette approche, il est nécessaire d'indiquer l'encodage à l'extérieur du flot.

Les standards ISO 2022 ont l'inconvénient d'être contextuels. Il se peut que des logiciels utilisant certains algorithmes de recherche manquent d'interopérabilité à cet égard.

Les formes de codage définies par le standard Unicode ont l'inconvénient de la présence éventuelle de la fonctionnalité d'indicateur d'encodage en début de flot, qui le cas échéant est introduit par le caractère Byte Order Mark. Certains logiciels anciens ne sont pas compatibles avec la présence de ces trois octets, et ne pourront pas l'être en raison de la complexité conceptuelle que représente le fait de traiter ces trois octets. En particulier, certaines opérations deviennent plus complexes comme la concaténation de chaînes.

Standardisation

Le jeu de codage ASCII est défini quasiment identiquement par plusieurs standards différents, a de nombreuses variantes et a donné naissance à une foison (des dizaines ou des centaines) d'extensions plus ou moins incompatibles entre elles.

Les principales extensions sont justifiées par le fait que l'ASCII ne répond pas aux divers besoins régionaux. Elles sont proposées par des organismes de normalisation, ou par des fournisseurs de produits et de services.

Les standards ASCII

Note: ne pas confondre USASI X3.4-1968 ou ANSI X3.4-1968 et ANSI X3.4:1986

Normes définissant ou ayant défini ce système de codage des caractères:

  • Les standards ASCII des États-Unis (les standards hérités, et le standard en vigueur)
    • ASA X3.4-1963, (incomplet avec 28 positions libres, et un code de commande non assigné)
    • USASI X3.4-1967, (renommé rétroactivement ANSI X3.4-1967); ne normalisait pas encore toutes les positions.
    • USASI X3.4-1968, (renommé rétroactivement ANSI X3.4-1968); ne normalisait pas encore toutes les positions.
    • ANSI X3.4-1977,
    • ANSI X3.4:1986 (en 1986, et en vigueur aujourd'hui)

Les standards internationaux suivants sont généralement considérés compatibles (quasi-identiques) avec le standard ASCII en vigueur de 1986 à 2011, tout en constituant une normalisation internationale officielle:

  • Norme ISO/CEI 646
    • ISO/CEI 646-US Variante des États-Unis
    • Variante IRV internationale
  • Code page IBM 367.
  • Alphabet International de Référence
    • Alphabet International de Référence no 5 (de 1988)[7].
    • Alphabet International de référence no 5 (dans le jeu G0 de l'IRV)[8].

La désignation US-ASCII ou ASCII é-u, ASCII des États-Unis est un mix des désignations précédentes. Le registre IANA lui attribue la dénomination US-ASCII, sans en définir le codage.

Approximation, variantes et extensions

  • Norme ISO/CEI 646
    • Variante INV invariable (incomplète par rapport aux deux précédentes)

Trois types de codages de caractères se rapprochent de l'ASCII :

  • ceux qui ne changent que par la dénomination ; ils sont essentiellement identiques à l'ASCII
  • ceux qui sont des variantes, l'ASCII étant à l'origine la variante locale aux États-Unis de l'ISO 646
  • ceux qui l'augmentent, dits extensions

Alias

En juin 1992, le RFC[9] et la chambre d'enregistrement de jeux de caractères Internet Assigned Numbers Authority [10] ont reconnu les alias insensibles à la casse suivants convenables pour l'utilisation dans des protocoles internet :
  • ANSI_X3.4-1968 (canonical name)
  • iso-ir-6
  • ANSI_X3.4-1986
  • ISO_646.irv:1991
  • ASCII (with ASCII-7 and ASCII-8 variants)
  • ISO646-US
  • US-ASCII (preferred MIME name)[10]
  • us
  • IBM367
  • cp367
  • csASCII

L'IANA promeut plus particulièrement la dénomination « US-ASCII » pour Internet.

Variantes

Article détaillé : ISO/CEI 646.

ASCII a donné naissance à certaines variantes de l’ASCII qui conservent la plupart des caractères mais en remplacent certains. Dès lors, il ne s’agit plus d’ASCII à strictement parler.

Huitième bit et augmentations

Article détaillé : ASCII étendu.

De nombreuses normes de codage de caractères ont repris les codes ASCII et ajouté d’autres caractères pour les codes supérieurs à 127.

Extensions mono-octets

En particulier, beaucoup de pages de codes étendent l'ASCII en utilisant le 8e bit pour définir des caractères numérotés de 128 à 255. La norme ISO/CEI 8859 fournit des extensions pour diverses langues. Par exemple, l’ISO 8859-1, aussi appelée Latin-1, étend l’ASCII avec les caractères accentués utiles aux langues originaires d’Europe occidentale comme le français ou l’allemand.

Par abus de langage, on appelle souvent « ASCII » des normes qui étendent ASCII, mais qui ne sont pas compatibles entre elles (et parfois même ne sont pas compatibles sur leurs 128 premiers caractères codés). En particulier, les standards Windows-1252 (couramment utilisé sur Microsoft Windows dans les pays occidentaux), ISO 8859-1 (couramment utilisé sur Internet et UNIX) et les pages de code pour PC numéro 437 et 850 (couramment utilisées sur DOS) ne sont pas la norme ASCII. Cet abus de langage ne va pas sans causer des confusions causant des incompatibilités, souvent rendues visibles par le fait que les caractères non ASCII comme les « lettres accentuées » (éÈç) s'affichent mal. On écrit parfois ASCII de base pour bien identifier ASCII, et pas un standard plus étendu.

Extensions asiatiques, à base de séquences d'échappement

Afin d’unifier les différents codages de caractères complétant l'ASCII et y intégrer les codages complètement différents (le JIS pour le japonais par exemple, qui bien que développé aussi sur la base de l’US-ASCII, en diffère dans l’assignation d’un des 128 premiers codets), la norme ISO/CEI 10646 a été inventée (et aussi développée au départ séparément par le Consortium Unicode dans une version de sa norme Unicode 1.0 initialement incompatible avec ISO/CEI 10646.

Voir notamment ISO 2022.

Extensions Unicode

La version 1.0 a été abandonnée depuis la version 1.1 afin d’unifier et fusionner les deux répertoires dans un jeu universel de caractères codés). ISO/CEI 10646 codifie des dizaines de milliers de caractères, mais les 128 premiers restent compatibles avec ASCII (dans sa dernière version X3.4-1986) ; la norme Unicode y ajoute des sémantiques supplémentaires.

Toutefois, certains pays d’Asie orientale (la République populaire de Chine, les anciens dominions britannique et portugais en Chine, de Hong Kong et Macao, qui sont devenus depuis des régions administratives spéciales de Chine, la République de Chine à Taïwan, et le Japon) ont choisi de continuer à développer leur propre norme pour coder le jeu de caractères universel, tout en choisissant de les maintenir entièrement convertibles avec l’ISO/CEI 10646 ; parmi ces normes asiatiques, seule la norme nationale japonaise continue à maintenir une différence dans ses 128 premières positions avec le jeu ASCII, en codant le symbole monétaire du yen à la place de la barre oblique inversée (comme c’est aussi le cas dans la variante japonaise de la norme ISO/CEI 646).

Parmi les nombreuses extensions 8 bits de l'ASCII, le Multinational Character Set créé par Digital Equipment Corporation pour le terminal informatique VT220 est considéré comme à la fois l'ancêtre de l'ISO 8859-1 et de l'Unicode[11].

Influence

L'ASCII a eu une influence importante dans le monde informatique. En particulier il a pendant longtemps limité les caractères disponibles aux caractères latins non accentués, notamment dans le monde de l'internet, que ce soit pour les noms de domaine, les adresses de courrier électronique, les caractères disponibles dans le Bios, ou les caractères dans lesquels peuvent être écrits des programmes informatiques.

Description

Table des 128 caractères ASCII

Table de correspondance ASCII

Dans la table suivante, les 33 caractères de contrôle (codes 0 à 31 et 127) sont présentés avec leur nom en anglais suivi d'une traduction entre parenthèses.

Code en base |  |  |  | Caractère | Signification
10 | 8 | 16 | 2
0 | 0 | 00 | 0000000 | NUL | Null (nul)
1 | 01 | 01 | 0000001 | SOH | Start of Header (début d'en-tête)
2 | 02 | 02 | 0000010 | STX | Start of Text (début du texte)
3 | 03 | 03 | 0000011 | ETX | End of Text (fin du texte)
4 | 04 | 04 | 0000100 | EOT | End of Transmission (fin de transmission)
5 | 05 | 05 | 0000101 | ENQ | Enquiry (End of Line) (demande, fin de ligne)
6 | 06 | 06 | 0000110 | ACK | Acknowledge (accusé de réception)
7 | 07 | 07 | 0000111 | BEL | Bell (caractère d'appel)
8 | 010 | 08 | 0001000 | BS | Backspace (espacement arrière)
9 | 011 | 09 | 0001001 | HT | Horizontal Tab (tabulation horizontale)
10 | 012 | 0A | 0001010 | LF | Line Feed (saut de ligne)
11 | 013 | 0B | 0001011 | VT | Vertical Tab (tabulation verticale)
12 | 014 | 0C | 0001100 | FF | Form Feed (saut de page)
13 | 015 | 0D | 0001101 | CR | Carriage Return (retour chariot)
14 | 016 | 0E | 0001110 | SO | Shift Out (fin d'extension)
15 | 017 | 0F | 0001111 | SI | Shift In (démarrage d'extension)
16 | 020 | 10 | 0010000 | DLE | Data Link Escape
17 | 021 | 11 | 0010001 | DC1 | Device Control 1 à 4 (DC1 et DC3 sont généralementutilisés pour coder XON et XOFF dans un canal de communication duplex)
18 | 022 | 12 | 0010010 | DC2
19 | 023 | 13 | 0010011 | DC3
20 | 024 | 14 | 0010100 | DC4
21 | 025 | 15 | 0010101 | NAK | Negative Acknowledge (accusé de réception négatif)
22 | 026 | 16 | 0010110 | SYN | Synchronous Idle
23 | 027 | 17 | 0010111 | ETB | End of Transmission Block (fin du bloc de transmission)
24 | 030 | 18 | 0011000 | CAN | Cancel (annulation)
25 | 031 | 19 | 0011001 | EM | End of Medium (fin de support)
26 | 032 | 1A | 0011010 | SUB | Substitute (substitution)
27 | 033 | 1B | 0011011 | ESC | Escape (échappement)
28 | 034 | 1C | 0011100 | FS | File Separator (séparateur de fichier)
29 | 035 | 1D | 0011101 | GS | Group Separator (séparateur de groupe)
30 | 036 | 1E | 0011110 | RS | Record Separator (séparateur d'enregistrement)
31 | 037 | 1F | 0011111 | US | Unit Separator (séparateur d'unité)
32 | 040 | 20 | 0100000 | SP | Espace (Space en anglais)
33 | 041 | 21 | 0100001 | ! | Point d'exclamation
34 | 042 | 22 | 0100010 | " | Guillemet droit
35 | 043 | 23 | 0100011 | # | Croisillon ou dièse ou signe numéro[8]
36 | 044 | 24 | 0100100 | $ | Dollar
37 | 045 | 25 | 0100101 | % | Pourcent
38 | 046 | 26 | 0100110 | & | Esperluette ou perluète[8]
39 | 047 | 27 | 0100111 | ' | Apostrophe ou guillemet fermant simple ou accent aigu[12]
40 | 050 | 28 | 0101000 | ( | Parenthèse ouvrante
41 | 051 | 29 | 0101001 | ) | Parenthèse fermante
42 | 052 | 2A | 0101010 | * | Astérisque
43 | 053 | 2B | 0101011 | + | Plus
44 | 054 | 2C | 0101100 | , | Virgule
45 | 055 | 2D | 0101101 | - | Moins ou tiret[8] ou trait d'union
46 | 056 | 2E | 0101110 | . | Point
47 | 057 | 2F | 0101111 | / | Barre oblique (Slash en anglais)
48 | 060 | 30 | 0110000 | 0 | Le chiffre zéro
49 | 061 | 31 | 0110001 | 1 | Le chiffre un
50 | 062 | 32 | 0110010 | 2 | Le chiffre deux
51 | 063 | 33 | 0110011 | 3 | Le chiffre trois
52 | 064 | 34 | 0110100 | 4 | Le chiffre quatre
53 | 065 | 35 | 0110101 | 5 | Le chiffre cinq
54 | 066 | 36 | 0110110 | 6 | Le chiffre six
55 | 067 | 37 | 0110111 | 7 | Le chiffre sept
56 | 070 | 38 | 0111000 | 8 | Le chiffre huit
57 | 071 | 39 | 0111001 | 9 | Le chiffre neuf
58 | 072 | 3A | 0111010 | : | Deux-points
59 | 073 | 3B | 0111011 | ; | Point-virgule
60 | 074 | 3C | 0111100 | < | Inférieur
61 | 075 | 3D | 0111101 | = | Égal
62 | 076 | 3E | 0111110 | > | Supérieur
63 | 077 | 3F | 0111111 | ? | Point d'interrogation
64 | 0100 | 40 | 1000000 | @ | Arobace ou arobase ou A commercial[8]
65 | 0101 | 41 | 1000001 | A |
66 | 0102 | 42 | 1000010 | B |
67 | 0103 | 43 | 1000011 | C |
68 | 0104 | 44 | 1000100 | D |
69 | 0105 | 45 | 1000101 | E |
70 | 0106 | 46 | 1000110 | F |
71 | 0107 | 47 | 1000111 | G |
72 | 0110 | 48 | 1001000 | H |
73 | 0111 | 49 | 1001001 | I |
74 | 0112 | 4A | 1001010 | J |
75 | 0113 | 4B | 1001011 | K |
76 | 0114 | 4C | 1001100 | L |
77 | 0115 | 4D | 1001101 | M |
78 | 0116 | 4E | 1001110 | N |
79 | 0117 | 4F | 1001111 | O |
80 | 0120 | 50 | 1010000 | P |
81 | 0121 | 51 | 1010001 | Q |
82 | 0122 | 52 | 1010010 | R |
83 | 0123 | 53 | 1010011 | S |
84 | 0124 | 54 | 1010100 | T |
85 | 0125 | 55 | 1010101 | U |
86 | 0126 | 56 | 1010110 | V |
87 | 0127 | 57 | 1010111 | W |
88 | 0130 | 58 | 1011000 | X |
89 | 0131 | 59 | 1011001 | Y |
90 | 0132 | 5A | 1011010 | Z |
91 | 0133 | 5B | 1011011 | [ | Crochet ouvrant
92 | 0134 | 5C | 1011100 | \ | Barre oblique inversée (backslash ou antislash en anglais)
93 | 0135 | 5D | 1011101 | ] | Crochet fermant
94 | 0136 | 5E | 1011110 | ^ | Accent circonflexe (avec chasse)
95 | 0137 | 5F | 1011111 | _ | Tiret bas ou trait bas[8] ou souligné (underscore en anglais)
96 | 0140 | 60 | 1100000 | ` | Accent grave (avec chasse)[13]
97 | 0141 | 61 | 1100001 | a |
98 | 0142 | 62 | 1100010 | b |
99 | 0143 | 63 | 1100011 | c |
100 | 0144 | 64 | 1100100 | d |
101 | 0145 | 65 | 1100101 | e |
102 | 0146 | 66 | 1100110 | f |
103 | 0147 | 67 | 1100111 | g |
104 | 0150 | 68 | 1101000 | h |
105 | 0151 | 69 | 1101001 | i |
106 | 0152 | 6A | 1101010 | j |
107 | 0153 | 6B | 1101011 | k |
108 | 0154 | 6C | 1101100 | l |
109 | 0155 | 6D | 1101101 | m |
110 | 0156 | 6E | 1101110 | n |
111 | 0157 | 6F | 1101111 | o |
112 | 0160 | 70 | 1110000 | p |
113 | 0161 | 71 | 1110001 | q |
114 | 0162 | 72 | 1110010 | r |
115 | 0163 | 73 | 1110011 | s |
116 | 0164 | 74 | 1110100 | t |
117 | 0165 | 75 | 1110101 | u |
118 | 0166 | 76 | 1110110 | v |
119 | 0167 | 77 | 1110111 | w |
120 | 0170 | 78 | 1111000 | x |
121 | 0171 | 79 | 1111001 | y |
122 | 0172 | 7A | 1111010 | z |
123 | 0173 | 7B | 1111011 | { | Accolade ouvrante
124 | 0174 | 7C | 1111100 | | | Barre verticale
125 | 0175 | 7D | 1111101 | } | Accolade fermante
126 | 0176 | 7E | 1111110 | ~ | Tilde
127 | 0177 | 7F | 1111111 | DEL | Delete (effacement)

On peut aussi présenter la table des caractères ASCII sous cette forme plus condensée qui met en évidence une organisation fondée sur la base 16.

PDF : fr en
 v · d · m
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
000
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
001
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
002
SP
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/
003
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
004
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
005
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
006
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
007
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
DEL

Caractères de contrôle

NUL

Originellement une NOP, un caractère à ignorer. Lui donner le code 0 permettait de prévoir des réserves sur les bandes perforées en laissant des zones sans perforation pour insérer de nouveaux caractères a posteriori. Avec le développement du langage C il a pris une importance particulière quand il a été utilisé comme indicateur de fin de chaîne de caractères.

SOH

Start of heading : début d'en-tête. Il est aujourd'hui souvent utilisé dans les communications séries pour permettre la synchronisation après erreur[14].

DEL

Delete : effacement. Lui donner le code 127 (1111111 en binaire) permettait de supprimer a posteriori un caractère sur les bandes perforées qui codaient les informations sur 7 bits. N'importe quel caractère pouvait être transformé en DEL en complétant la perforation des 7 bits qui le composaient.

LF, CR, fin de ligne

Dans un fichier texte, la fin d'une ligne est représentée par un ou deux caractères de contrôle. Plusieurs conventions existent :

  • sur les systèmes Multics, Unix, Type Unix (Linux, AIX, Xenix, Mac OS X, etc.), BeOS, AmigaOS, RISC OS entre autres, la fin de ligne est indiquée par un saut de ligne (LF) ;
  • sur les machines Apple II et Mac OS jusqu'à la version 9, la fin de ligne est indiquée par un retour chariot (CR) ;
  • sur les systèmes DEC, RT-11 et généralement tous les premiers systèmes non-Unix et non-IBM, CP/M, MP/M, MS-DOS, OS/2 ou Microsoft Windows, la fin de ligne est indiquée par un retour chariot suivi d'un saut de ligne (CR suivi de LF).

Ainsi, lorsqu'on transfère un fichier ASCII entre des systèmes ayant des conventions de fin de ligne différentes, il faut convertir les fins de ligne pour pouvoir le manipuler confortablement sur le système cible. Autrement, il faut utiliser un éditeur de texte capable de gérer les diverses conventions de fin de ligne, ce qui n'est par exemple pas le cas du classique Bloc-notes de Microsoft Windows. Les programmes utilisant les fichiers ASCII ne sont en général pas perturbés par un changement de type de fin de ligne.

SUB

Il est souvent associé à la combinaison de touche Contrôle + z, et est utilisé dans les communications séries pour permettre l'envoi des données en lieu et place de la touche entrée.

Voir aussi

Notes et références

  1. ↑ http://www.trailing-edge.com/~bobbemer/SURVEY.HTM [archive]
  2. ↑ http://discover.lib.umn.edu/cgi/f/findaid/findaid-idx?c=umfa;cc=umfa;rgn=main;view=text;didno=cbi00067 [archive]
  3. ↑ http://www.cs.tut.fi/~jkorpela/latin1/ascii-hist.html [archive]
  4. ↑ Appendix §A.6.8 de la norme de A963
  5. ↑ Becker Pascal, Histoire des supports informatiques (lire en ligne [archive])
  6. ↑ (fr) Unicode 5.0 en pratique, chapitre 7 « Ponctuation » [archive], Patrick Andries.
  7. ↑ Alphabet International de référence no 5, Union international des télécommunications,‎ 1988 (lire en ligne [archive])
  8. ↑ a, b, c, d, e et f Alphabet International de référence : ANCIEN ALPHABET INTERNATIONAL no 5 ou AI5, Union international des télécommunications,‎ 1992 (lire en ligne [archive])
  9. ↑ (en) Rationel Almen Planlaegning, Request for Comments: 1345 : Character Mnemonics & Character Sets, Network Working Group,‎ juin 1992 (RFC 1345 [archive]).
  10. ↑ a et b Internet Assigned Numbers Authority (May 14, 2007). "Character Sets [archive]". Accessed 2008-04-14.
  11. ↑ Roman Czyborra, « ISO 8859-1 and MCS, from ISO 8859 Alphabet Soup » [archive]
  12. ↑ La norme ANSI X3.4 définit le caractère 39 par apostrophe (closing single quotation mark, acute accent) et les anciennes tables de caractères le représentaient souvent incliné. Les encodages plus récents restreignent ce code à la représentation de l'apostrophe verticale (ni penchée à droite, ni à gauche, mais neutre). Voir (en) Latin-1's apostrophe, grave accent, acute accent [archive].
  13. ↑ Le code 96 est également employé comme guillemet ouvrant simple en ASCII. En Unicode, il existe un code plus approprié.
  14. ↑ (en) ASCII character set [archive]


ASCII Table and Description

ASCII stands for American Standard Code for Information Interchange. Computers can only understand numbers, so an ASCII code is the numerical representation of a character such as 'a' or '@' or an action of some sort. ASCII was developed a long time ago and now the non-printing characters are rarely used for their original purpose. Below is the ASCII character table and this includes descriptions of the first 32 non-printing characters. ASCII was actually designed for use with teletypes and so the descriptions are somewhat obscure. If someone says they want your CV however in ASCII format, all this means is they want 'plain' text with no formatting such as tabs, bold or underscoring - the raw format that any computer can understand. This is usually so they can easily import the file into their own applications without issues. Notepad.exe creates ASCII text, or in MS Word you can save a file as 'text only'


IBM Scan Codes

The following table is nothing to do with ASCII, but has been requested by a number of you out there. When a key on your keyboard is pressed, a code is sent which can be recognised by software. Programmers will find the most use for this table to map keys to actions for the function keys etc.

EBCDIC

ASCII is not the only format in use out there. IBM adopted EBCDIC (Extended Binary Coded Decimal Interchange Code) developed for punched cards in the early 1960s and still uses it on mainframes today. It is probably the next most well known character set due to the proliferation of IBM mainframes. It comes in at least six slightly differing forms, so again here is the most common.


ANSI.SYS — Wikipédia

ANSI.SYS

Un article de Wikipédia, l'encyclopédie libre.

Le fichier ANSI.SYS est un pilote de périphérique du MS-DOS de la société Microsoft qui implémente partiellement un sous-ensemble de contrôle des terminaux textes proposé par l'ANSI

X3L2 Technical Committee on Codes and Character Sets (the "X3 Committee"). Il étend les fonctionnalités d'une console dépourvue de ce support.

Dans les environnement de la famille Linux, ce fichier n'est pas nécessaire dans la mesure ou des fonctionnalités équivalentes sont fournies par d'autres moyens.

Les terminaux VT100 incluent également un système équivalent (en fait la première mise en œuvre). Les systèmes même s'ils sont hétérogène sont en partie interopérables.

Les fonctionnalités implémentées telles que la couleur ou les déplacements de curseur le sont au travers de chaînes d'octets mêlées au texte à l'aide de ta technique de dite séquence d'échappement qui commence par l'octet d'échappement. Dans la plupart des encoding, ce caractère d'échappement à la valeur 27-décimal (c'est donc en particulier le cas dans les encodings des familles ASCII/Unicode), mais sur les système EBCDIC, le caractère d'échappement eut prendre la valeur 39-décimal[1].

Application

Le pilote ANSI.SYS fait partie de plusieurs systèmes d'exploitation Microsoft dont :

  • MS-DOS
  • Windows 95
  • Windows 98
  • Windows NT
  • Windows 2000
  • Windows XP
  • Windows Vista
  • Windows 2003 (version x86)

ANSI.SYS est nécessaire pour faire afficher des graphismes élaborés en mode texte en particulier pour redéfinir la couleur. D'ailleurs ces fichiers portent souvent l'extension ".ANS". D'autre part, ces séquences étaient utilisés pour construire des jeux en mode texte avec un fichier Batch.

Ces fonctionnalités permettent par exemple à des applications comme cygwin d'offre des fonctionnalités semblables à celles disponibles sous linux, comme d'afficher en couleur les fichiers en fonctions de propriétés particulières.

Exemple:

 brw-r--r--    1 unixuid équipe 64,  64 Jan 27 05:52 block
 crw-r--r--    1 unixuid équipe 64, 255 Jan 26 13:57 caractère
 -rw-r--r--    1 unixuid équipe     290 Jan 26 14:08 compressé.gz
 -rw-r--r--    1 unixuid équipe  331836 Jan 26 14:06 donnée.ppm
 drwxrwx--x    2 unixuid équipe      48 Jan 26 11:28 répertoire
 -rwxrwx--x    1 unixuid équipe      29 Jan 26 14:03 exécutable
 prw-r--r--    1 unixuid équipe       0 Jan 26 11:50 fifo
 lrwxrwxrwx    1 unixuid équipe       3 Jan 26 11:44 lien -> rép
 -rw-rw----    1 unixuid équipe     217 Jan 26 14:08 régulier

Syntaxe

Pour utiliser ANSI.SYS sous MS-DOS, il faut ajouter la ligne suivante au fichier config.sys :

device=[lecteur:][chemin]ANSI.SYS

où [lecteur:] et [chemin] sont les lecteurs et chemins où trouver le pilote ANSI.SYS.

Remarque : il existe sous FreeDOS, un utilitaire appelé NANSI.EXE qui est un programme résident et qui a les mêmes fonctionnalités qu'ANSI.SYS fourni avec MS-DOS.

Fonctionnalités

Une fois chargé, ANSI.SYS permet de modifier la position du curseur, d'afficher du texte en couleur (les couleurs d'avant plan et d'arrière plan peuvent être modifiées), et changer de mode graphique et surtout de redéfinir des touches du clavier, ce qui permet de programmer des macros (ceci était très utiles avant l'apparition de DOSKEY avec le MS-DOS 5.0).

Voici quelques séquences d'échappement :

Code | Effet
CSI = n h | Définit le mode écran.
CSI = n l | Annule le mode d'affichage.
CSI code ; param [ ; param ] p | Redéfinit une touche du clavier.

Modes d'écran
Mode | Description | Mode | Description
0 | 40 × 25 mono | 1 | 40 × 25 couleurs
2 | 80 × 25 mono | 3 | 80 × 25 couleurs
4 | 320 × 200 couleurs | 5 | 320 × 200 mono
6 | 640 × 200 mono | 14 | 640 x 200 couleurs (mode graphique en 16 couleurs)
13 | 320 x 200 couleurs (mode graphique) | 19 | 320 x 200 couleurs (mode 256 couleurs)
15 | 640 x 350 monochrome (mode graphique) | 16 | 640 x 350 couleurs (mode graphique 16 couleurs)
17 | 640 x 480 monochrome (mode graphique) | 18 | 640 x 480 couleurs (mode 16 couleurs)
7 | Passage automatique à la ligne suivante (scrolling) |  |


Art ASCII — Wikipédia

Art ASCII

Un article de Wikipédia, l'encyclopédie libre.
_________________________________________________
|             _       _    ____   ____ ___ ___  |
|   __ _ _ __| |_    / \  / ___| / ___|_ _|_ _| |
|  / _` | '__| __|  / _ \ \___ \| |    | | | |  |
| | (_| | |  | |_  / ___ \ ___) | |___ | | | |  |
|  \__,_|_|   \__|/_/   \_\____/ \____|___|___| |
|_______________________________________________|

L'art ASCII consiste à réaliser des images uniquement à l'aide des lettres et caractères spéciaux contenus dans le code ASCII.

Description

Cette pratique a commencé avec les mainframes, où ce genre d'images permettait de montrer ce qu'il était possible de faire avec une imprimante bien menée. Les images étaient alors d'une largeur de 120 ou 132 caractères pour une longueur variable, et autorisaient les superpositions multiples de caractères. Une image de ce type très répandue dans les années 1960 était un portrait de Brigitte Bardot. Des machines couplées à des caméras vidéo imprimèrent par la suite des portraits sur papier dans des galeries commerciales (parfois aussi sur des T-shirts par une méthode de transfert).

La pratique s'est plus tard répandue par le biais des premiers BBS, sur lesquels il n'était pas possible d'afficher autre chose que du texte. La superposition de caractères disparut à mesure que les écrans remplaçaient les terminaux de type machine à écrire.

À partir des années 1980, certains artistes ont utilisé des jeux de caractères étendus tels que la page de code 437, disponible en mode texte sur compatible PC.

On peut réaliser de l'art ASCII avec un simple éditeur de texte à l'aide d'une police de caractères à chasse fixe (par exemple : Courrier New), mais il existe des logiciels automatisant le processus, à l'aide d'algorithmes de conversion d'image en texte. Évidemment ces images, si elles sont faites à la main, demandent beaucoup de temps et de talent, d'où le terme « art ».

Types et exemples d'art ASCII

Article détaillé : Émoticône.

La forme la plus simple d'art ASCII est la combinaison de deux ou trois caractères pour exprimer une émotion en texte. Effectuez mentalement la rotation de 90° de ces exemples pour une orientation plus compréhensible de ceux-ci, ou penchez la tête à gauche.

             :-) ou  :) ou =) sourire
             :-( ou  :( ou =( triste
             :'(             pleure
            ;-) ou ;)       clin d'œil
             :-D ou  :D ou =D rire
            XD              mort de rire (paupières serrées)
             :-P ou  :P ou =P tire la langue
            B-) ou 8-)      cool (lunettes de soleil)
            Xo              souffrant
             :')             pleure de joie
             :S              malade, gêné

Il y a un autre type d'art ASCII en une ligne qui ne nécessite pas de rotation. Ils sont parfois appelés « smileys japonais ». Exemples :

       (^_^)         (Smiley homme)

        d~.~b        (Écoute au casque)

        \(^o^)/      (Youpi ! / Panique)

   (o.~) ou ^_-      (Clin d'œil)

          ^_^        (Content)

         (-_-)ZZZ    (Dort)

         ``(ToT)´´   (Pleure)

         (?_?)       (Confus)

         (^.^)       (Smiley femme)

          -_-        (Fatigué, accusateur ou exaspéré)

          x_x        (Mort)

 (_)_TNT___)------*  (TNT)

          -_-'       (Gêné - par quelqu'un)

         (*^_^*)     (Rougit, timide)

        -`(0_o)´- ou  O_o   (Impressionné et/ou confus et/ou choqué)

     (!_!) / (o_o)   (Choqué)

Il est également possible de représenter des animaux et des silhouettes :

     >(°< °)<  ou  \_/o<  (Oiseau)

           <:3))))~~      (Souris, rat)

            >##\°)        (Poisson)

          \o/  (Victoire : silhouette bras levés)

          _o/  (Adieux ou salutation : silhouette un bras levé)

          /o\  (Consternation : tête dans les mains)

Et une « image ASCII (étendu...) de Freud[1] », plus évocatrice en police sérif, de son célèbre portrait de 1926 par Ferdinand Schmutzer : [ ( `;-£›‹>⋅⋅•⋅\ ]
datée du début des années 2000.

Ensuite il existe des figures plus complexes, qui nécessitent plusieurs lignes :

                  (_) |  (_)              | (_)
 () ()   __      ___| | ___ _ __   ___  __| |_  __ _
 (-.-)   \ \ /\ / / | |/ / | '_ \ / _ \/ _` | |/ _` |
 (   )    \ V  V /| |   <| | |_) |  __/ (_| | | (_| |
(") (")o   \_/\_/ |_|_|\_\_| .__/ \___|\__,_|_|\__,_|
                           | |
                           |_|

          _..-/  /  |  \    \   _|/|
         \      /-./_ \;   \    \,;'   \
         ,\    / \:  `:\    \   //    `:`.
       ,'  \  /-._;   |  :     :  ::    ,.   .
     ,'      ::   /`-._| |    | || '  :  `.`.)
  _,'       |;._:: |  | |    | `|    :    `'
,'   `.     /   |`-:_ ; |    |  |   : \
`--.   )   /|-._:     :          |   \ \
   /  /    :_|   ;`-._;   __..--';     :  :
  /  (    ;|;-./_  _/.-:'o |   /     ' |
 /  , \._/_/_./--/_|:|___|_,'        | |
:  /   `'-'--'----'---------'          |
|  :     O ._O   O_. O ._O   O_.      ; ;     Un bateau viking (drakkar)
: `.      //    //    //    //     ,' /

/\_/\___  _   /__   \_   _| |__   ___
\_ _/ _ \| | | |/ /\/ | | | '_ \ / _ \
 / \ (_) | |_| / /  | |_| | |_) |  __/
 \_/\___/ \__,_\/    \__,_|_.__/ \___| Logo youtube
           (__)
           (oo)                                                     \                 (\_/) (\___/)
    /-------\/      __        O             \O/          (\___/)     \ /\     ()_()   (^_^) (='.'=)    _[ ]_
   / |     ||      /o)\      /|\             |           (='.'=)     ( )     (='.'=)  (>$<) ( U U )   \('o')/
  *  ||----||      \(o/      / \            / \          (")_(")   .( o ).   (")_(")  (/ \) (")_(")    ( : )
     ~~    ~~
      Vache     Yin/Yang   Personne  Personne contente         Cinq exemples de lapins              Bonhomme de neige

Certaines personnes utilisent l'art ASCII comme signatures dans leurs courriels ou leurs posts sur des forums. Ce dessin qui ressemble à une vache est en fait un gnou. C'est un Easter Egg de apt-get, un gestionnaire de paquets pour certains systèmes GNU/Linux (prononcer "gnou/linux").

                 _a,
                _yQa.
               _qTWW(
               je`?QX:
              <d+ -3Wm;
             _qos_s%mWw,
             a2?????TWW(
            sd(     -?Qm;.
          .amm;     .xmWmc
          """""`    """""""

           \\\||||||////
            \\  ~ ~  //
             (  @ @  )
    ______ oOOo-(_)-oOOo___________
    .......
    .......
    .......
    _____________Oooo._____________
       .oooO     (   )
        (   )     ) /
         \ (     (_/
          \_)

Parfois on rencontre aussi des mots dont les lettres sont constituées d'elles-mêmes. C'est ainsi qu'étaient souvent composées les pages de garde des travaux d'impression sur les machines imprimant en continu des sorties de travaux batch.

      HHHHHH    HHHHHH    IIIIII     !!!
       HHHH      HHHH      IIII     !!!!!
       HHHH      HHHH      IIII     !!!!!
       HHHH      HHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII      !!!
       HHHH      HHHH      IIII
       HHHH      HHHH      IIII      !!!
       HHHH      HHHH      IIII     !!!!!
      HHHHHH    HHHHHH    IIIIII     !!!

On peut aussi s'en servir pour créer de la typographie, par exemple :

       ___              __,
      ( /              (          o _/_ /
       / __,  _   _     `.  _ _,    /  /_
     _/_(_/(_/ /_(/_  (___)/ / /_(_(__/ /_
    //
   (/

Voici un exemple d'art ASCII apparu sur Amiga. Ce genre d'art ASCII est fait à la main dans un éditeur de texte :

                   ______.----------------------------.______
                 :_)                                        (_:
             ....|:                                          :|....
             :  :<>                                          <>:  :
             :···|:                                          :|···:
         .---+- -:-                                          -:- -+---.
      /\___  |    /\___      /\_____     /\______     /\______    |   /\___
    _/    /  |  _/    /___ _/ __   /   _/  __   /   _/  __   /    : _/    /
    \  __//\ :/\\   _//  / \  )/  //\  \   )/  //\  \   )/  //\  /\ \_   //\
  _/¯¯ \)¯  \/  ¯¯ __¯   \/¯¯ ¯  ¯¯  \/¯¯  ¯_ ¯¯  \/¯¯  ¯_ ¯¯  \/  ¯)/  ¯¯  \_
  \                )/¯                     (/           (/          ¯        /
 /¯¯               /                       /            /            _      ¯¯\
 \_           /\__/        /\_        /\__/        /\__/         /\_(/       _/
 =/          /===/        /==/       /===/        /=©d/         /=:=/       /=
  ¯¯¯¯¯¯¯¯¯\/:   :¯¯¯¯¯¯\/   ¯¯¯¯¯¯\/    ¯¯¯¯¯¯¯\/    ¯¯¯¯¯¯¯¯\/  | ¯¯¯¯¯¯\/
   ______.---+-  :____ /\_____  :              :      ________:  -+---.______
 :_)·····    :.....  _/      /--+--./\_____.---+---./\___    .....:    ·····(_:
 |:           : ..:..\      /   : _/      /    :  _/    /  ..:.. :           :|
 <>           :.:.: : \  __//\  /\\  __  //\  /\  \_   //\ : :.:.:           <>
 |:             :..._/¯¯ \)¯  \/  ¯¯ )/ ¯¯  \/  ¯¯)/  ¯¯  \_...:             :|
 :        ____ ____ \                ¯            ¯        / ____ ____        :
 \_.     _\_  \\  //¯¯                            _       ¯¯\\  //  _/_     ._/
 ---· _  \¯ _  \\ \\_           /\_           /\_(/        _// //  _ ¯/  _ ·---
 /¯·  \¯¯¯ ¯\¯¯¯ ¯¯=/          /:=/          /=:=/        /= ¯¯ ¯¯¯/¯ ¯¯¯/  ·¯\
 :     ¯¯¯¯¯¯       ¯¯¯¯¯¯¯¯¯\/-+--¯¯¯¯¯¯¯¯\/--+--¯¯¯¯¯¯\/         ¯¯¯¯¯¯    :
 |:                             :              :                             :|
 <>                          .              .                                <>
 |:                      _ . | __ .__.__   .|__  __    .                     :|
 :¯).....             __(__|-|(_/_| (| ((__||__)(__)(__|__             .....(¯:
   ¯¯¯¯¯¯·-----------·-------|----|--|----(/----------(/--·-----------·¯¯¯¯¯¯

Voici Tux, le manchot mascotte du système d'exploitation GNU/Linux :

            .-"""-.
           '       \
          |,.  ,-.  |
          |()L( ()| |
          |,'  `".| |
          |.___.',| `
         .j `--"' `  `.
        / '        '   \
       / /          `   `.
      / /            `    .
     / /              l   |
    . ,               |   |
    ,"`.             .|   |
 _.'   ``.   o     | `..-'l
|       `.`,        |      `.
|         `.    __.j         )
|__        |--""___|      ,-'
   `"--...,+""""   `._,.-' mh

De nos jours l'art ASCII est rarement réalisé à la main, mais plutôt par des logiciels qui facilitent la création d'œuvres de plus en plus complexes.
Voici par exemple un smiley réalisé en art ascii.

                          oooo$$$$$$$$$$$$oooo
                      oo$$$$$$$$$$$$$$$$$$$$$$$$o
                   oo$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o         o$   $$ o$
   o $ oo        o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o       $$ $$ $$o$
oo $ $ "$      o$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$o       $$$o$$o$
"$$$$$$o$     o$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$o    $$$$$$$$
  $$$$$$$    $$$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$
  $$$$$$$$$$$$$$$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$$$$$$  """$$$
   "$$$""""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$
    $$$   o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$o
   o$$"   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$       $$$o
   $$$    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" "$$$$$$ooooo$$$$o
  o$$$oooo$$$$$  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$   o$$$$$$$$$$$$$$$$$
  $$$$$$$$"$$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$""""""""
 """"       $$$$    "$$$$$$$$$$$$$$$$$$$$$$$$$$$$"      o$$$
            "$$$o     """$$$$$$$$$$$$$$$$$$"$$"         $$$
              $$$o          "$$""$$$$$$""""           o$$$
               $$$$o                                o$$$"
                "$$$$o      o$$$$$$o"$$$$o        o$$$$
                  "$$$$$oo     ""$$$$o$$$$$o   o$$$$""
                     ""$$$$$oooo  "$$$o$$$$$$$$$"""
                        ""$$$$$$$oo $$$$$$$$$$
                                """"$$$$$$$$$$$
                                    $$$$$$$$$$$$
                                     $$$$$$$$$$"
                                      "$$$""

Certaines œuvres nécessitent presque de s'éloigner de l'écran ou de plisser les yeux pour apprécier le travail réalisé.

|JM/:::::::::J::::::::J::::::::::L|JMMMMMMMMMMMMMMMMM|
||M::::::::::F::::::::F::::J::::JMJFMMMMMMMMMMMMMMMMM|
J|F:::::;:::J::::::::/L::::FL:::LM'MMMMMMMMMMMMMMMMMM|
:`:::::/L:::|L::::::/M|:::JM|::/MMMMMMMMMMMMMMMMMMMMMF
:::::://::\:|J:::::JMM|:::FM|:/MMMMMMMMMMMMMMMMMMMMMM-
:;'::/J:::F\JM\::::FMMJ::JMM|/MMMMMMMMMMMMMMMMMMMMMMF
'.::/MMF:JMM\LM\::JMMMM\:|MM'MMMMMMMMMMMMMMMMMMMMMMM -
::;dMMM|:FMMM`MM\:|MMMMML|MMMMP"ooMMMMMMMMMMMMMMMMMF-
:/MMMMM|:MMMP"TTQ\LMMMMM|FMMP;\o#J__MMMMMMMMMMMMMMM  -
/MMMMMM|F-. |o#J__\  )MM'MP' `""""  QMMMMMMMMMMMMMF -
M/\MMMM/J  '-"""      J/ '          MMMMMMMMMMMMM/ - -
/::\MMMMML                J.       JMMMMMMMMMMMMM - -
\::::QMMMJ                CD;      MMMMMMMMMMMMMF- - -
:\:::::QMM\               J'      JMMMMMMMMMMMM/- - -
\:\::Lb:\MMb._                   /MMMMMMMMM/\M/- - - -
 \:\:JMMb\MM\"`-       .---     /MMMMMMMMM/ /'- - - -
- `(`:\MMMMMMb.                /MMMMMMMMP' - - - - - -
 - - -\\MMMMMMMb-             /MMP"QMMP'- - - - - - -
- - - -\\MMMJMMMb.          .dMMM|/MP' - - - - - - - -
 - - - -`\`Q|MMMMMbo._    .dMMMMMJ"'- - - - - - - - -
- - - - - - F`QMMMMMMMboodMMMMMMMML- - - - - - - - - -
 - - - - - J  ,`QMMMMMMMMMMMMMMMMMJ - - - - - - - - -
- - - - - -F  |o.\MMMMMMMMMMMMMMMMML - - - - - - - - -
 - - - - -J   FMMM\MMMMMMMMMMMMMMMMJ- - - - - - - - -
- - - - -/   /MMMMMb.MMMMMMMMMMMMMMM\- - - - - - - - -

          .   ,
       '. '.  \  \
      ._ '-.'. `\  \
        '-._; .'; `-.'.
       `~-.; '.       '.
        '--,`           '.
           -='.          ;
 .--=~~=-,    -.;        ;
 .-=`;    `~,_.;        /
`  ,-`'    .-;         |
   .-~`.    .;         ;
    .;.-   .-;         ,\
      `.'   ,=;     .-'  `~.-._
       .';   .';  .'      .'   '-.
          .\  ;  ;        ,.' _  a',
         .'~";-`   ;      ;"~` `'-=.)
       .' .'   . _;  ;',  ;
       '-.._`~`.'  \  ; ; :
            `~'    _'\\_ \\_
                  /=`^^=`""/`)-.
                  \ =  _ =     =\
                   `""` `~-. =   ;

Wikip  iaWi  pedia ikiped  Wikipe   Wik pediaW kipediaWik  ediaWikiped   ikipedi     pediaW       aWi
ipedi  ikip  iaWik pediaW  ipedi    ipe iaWiki  diaWikiped aWikipediaWi  pediaWiki   iaWiki      ikipe
 iaWi  pedi  ikip   aWik    iaW    ed    kipe   Wiki    aWikipe    ikip  iaWikipedi   kipe       pedia
  kip   aWi  ped     ipe    iki   ia      dia   ipediaWikip dia          ikip   aWik   dia      diaWik
  edi  ikip  ia      edi    pediaWi       aWi   diaWikiped  Wikipe        edi   kipe   aWi      Wik ped
   Wi  pediaWik      Wik    iaWikip       ipe   Wikipedia   ipediaW       aWi    dia   ipe     kipediaWi
   ipediaWikipe      ipe    ikipedi       dia   ipe         diaWiki       kip   aWik   dia     ediaWikip
    iaWikipedia      dia    ped  Wik      Wik   dia         Wik          pedi  ikipe   Wik    iaWi   edia
     kip  iaWi      aWik    iaW  ipe     kipe   Wik         iped    kip diaWikipedia  kipe    iki     Wik
      d   ikip     ikiped  Wikip diaWikipediaW kipedi      ediaWik pedi WikipediaWi  pediaW kipedi   kipedi
      Wi   ed      pediaWikipedi WikipediaWikipediaWi      aWikipediaWi ipediaWik    iaWikipediaWi   ediaWi

Notez que celui-ci est de l'ANSI ART, un dérivé de l'ASCII ART, car il a été teinté de gris. Les dégradés et gris typographique se font donc uniquement avec lettres, comme sur l'exemple suivant.

Le logo de Wikipédia en art ASCII (composé de 7857 caractères)

WP logo ASCII art 7857 chars.png

Notes et références

  1. ↑ Plongées dans La Fontaine [1] [archive].


American Standard Code for Information Interchange — Wikipédia

American Standard Code for Information Interchange

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur les redirections « ASCII » redirige ici. Pour les autres significations, voir ASCII (homonymie).

ISO-646-02 ou ISO-646-06 (ASCII)
Famille | ISO-646
Langues | Anglais
Nombre de caractères | 94
État du projet | Norme établie
Plates-formes | Toutes
Organisme / Parrainage | ISO / American National Standard
Numéro d'enregistrement | 002 et 006
Licence | Norme ISO payante
Séquences d'échappement | 002: jeu G0: ESC 2/8 4/0 jeu G1: ESC 2/9 4/0 006: jeu G0: ESC 2/8 4/2 jeu G1: ESC 2/9 4/2
Unité de codage (codet) | Sept à huit bits suffisent
Première version | ISO-646-02 et ISO-646-06 (01 12 1975)
Site web | [1]
modifier Consultez la documentation du modèle
Les 95 caractères ASCII affichables :
 !"#$%&'()*+,-./
0123456789:;<=>?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ[\]^_
`abcdefghijklmno
pqrstuvwxyz{|}~
Cette section doit être recyclée. Une réorganisation et une clarification du contenu sont nécessaires. Discutez des points à améliorer en page de discussion.

L'American Standard Code for Information Interchange (Code américain normalisé pour l'échange d'information), plus connu sous l'acronyme ASCII ([aski?]) est une norme de codage de caractères en informatique ancienne et connue pour son influence incontournable sur les codages de caractères qui lui ont succédé. Elle était la plus largement compatible pour ce qui est des caractères latins non accentués.

ASCII contient les caractères nécessaires pour écrire en anglais. Les caractères accentués sont fournis par d'autres normes, comme aujourd'hui, l'Unicode. Le jeu de caractères codés ASCII est le principal système qui a permis l'échange de textes en anglais à un niveau mondial, limitant ainsi l'usage des langues locales au travers d'extensions régionales.

L'ASCII est une des variantes de l'ISO/CEI 646. Il est inclus dans plusieurs dizaines de normes et standards augmentant les caractères disponibles ou extensions (ASCII étendu) Celles-ci peuvent être régionales (ISO/CEI 8859), nationales (GB 18030) ou internationales (ISO 2022, ISO/CEI 10646 ou Unicode). Avec l'avènement de la mondialisation et de l'internationalisation des systèmes d'information, les limitations de l'ASCII ne sont plus acceptées que dans des domaines très techniques qui requirent la compatibilité avec des protocoles ou systèmes anciens. Malheureusement, l'ASCII n'a donné naissance qu'à des normes de codage incompatibles entre elles.

Dans la norme Unicode, le standard ASCII est défini sous le nom de « C0 Controls and Basic Latin ».

Sommaire

  • 1 Histoire
  • 2 Principes
    • 2.1 Limitations
  • 3 Internationalisation
  • 4 Standardisation
    • 4.1 Les standards ASCII
  • 5 Approximation, variantes et extensions
    • 5.1 Alias
    • 5.2 Variantes
    • 5.3 Huitième bit et augmentations
      • 5.3.1 Extensions mono-octets
      • 5.3.2 Extensions asiatiques, à base de séquences d'échappement
      • 5.3.3 Extensions Unicode
  • 6 Influence
  • 7 Description
    • 7.1 Table des 128 caractères ASCII
    • 7.2 Caractères de contrôle
      • 7.2.1 NUL
      • 7.2.2 SOH
      • 7.2.3 DEL
      • 7.2.4 LF, CR, fin de ligne
      • 7.2.5 SUB
  • 8 Voir aussi
    • 8.1 Notes et références
    • 8.2 Bibliographie
    • 8.3 Articles connexes

Histoire[ modifier | modifier le code ]

Avant la standardisation, de nombreux codages de caractères incompatibles entre eux existaient[1].

En 1960, l'ISO a créé le technical committee on computers and information processing[2]. Il a été divisé en six groupes de travail.

  • Working Group A: Glossary
  • Working Group B: Character Sets and Coding
  • Working Group C: Character Recognition
  • Working Group D: Input and Output Media
  • Working Group E: Programming Languages
  • Working Group F: Digital Data Transmission

L'American Standards Association était chargé du standard des États-Unis.

L'ANSI a reconnu le consortium Business Equipment Manufacturers Association (BEMA, puis, CBEMA) comme le parrain du travail de standardisation du traitement des données. En 1960 BEMA a formé un groupe de traitement des données des partenaires, dont Minneapolis-Honeywell. Ce groupe a formé un Plans and Policies Committee, qui à son tour a formé l'Engineering Committee. L'Engineering Committee a formé le comité X3, qui a été reconnu par l'ASA comme sectional committee.

La liste des caractères à considérer et leur position ont été débattues[3].

Elle a été inventée par l'américain Bob Bemer en 1961.[réf. nécessaire]

En 1961, le DoD met au point un code standard de transmission de donnée sur 8 bits[4]. Ce standard 8 bits est une variante des standards FIELDATA sixbits utilisés dans la décennie précédente par la défense. Il a eu une influence notable sur la première version de l'ASCII.

En 1963, la première version publiée de l'ASCII apparaît.

Auparavant, d'autres standards étaient utilisés notamment sur les cartes perforées[5].

Sa dernière version stabilisée a été normalisée par l’ANSI en 1986 sous la désignation ANSI X3.4:1986 (après deux autres versions en 1967 et 1968, historiquement normalisées par l’ASI, devenu ANSI mais qui ne normalisait pas encore toutes les positions). C’est également la variante américaine des jeux de caractères codés selon la norme ISO/CEI 646 avec laquelle on la confond souvent (d’où sa désignation également comme US-ASCII pour lever l’ambigüité, désignation préférée dans le registre IANA des jeux de caractères codés).

À l'époque elle a été en concurrence avec des standards incompatibles. Par la suite, l'existence de nombreux codages reprenant les conventions de l'ASCII l'a rendu très populaire.

Principes[ modifier | modifier le code ]

L'ASCII définit seulement 128 caractères numérotés de 0 à 127 et codés en binaire de 0000000 à 1111111. Sept bits suffisent donc pour représenter un caractère codé en ASCII. Toutefois, les ordinateurs travaillant presque tous sur un multiple de huit bits (multiple d'un octet) depuis les années 1970, chaque caractère d'un texte en ASCII est souvent stocké dans un octet dont le 8e bit est 0. Aujourd'hui encore, certains systèmes de messagerie électronique et de SMS fonctionnent avec des bytes ou multiplet composés de seulement sept bits (contrairement à un octet qui est un byte ou multiplet standardisé à huit bits).

Les caractères de numéro 0 à 31 et le 127 ne sont pas affichables ; ils correspondent à des commandes de contrôle de terminal informatique. Le caractère numéro 127 est la commande pour effacer. Le caractère numéro 32 est l'espace. Les autres caractères sont les chiffres arabes, les lettres latines majuscules et minuscules sans accent et quelques symboles de ponctuation.

L'absence des caractères des langues étrangères à l'anglais rend ce standard insuffisant à lui seul pour des textes étrangers (par exemple en langue française), ce qui rend nécessaire l'utilisation d'autres encodages.

Lorsqu'il est employé seul pour la langue anglaise, il interdit l'usage des accents dans la langue anglaise (cf wikt:en:Appendix:English words with diacritics).

Limitations[ modifier | modifier le code ]

Quelques-uns des caractères graphiques ASCII ont provoqué une polysémie. Ceci est en tout ou partie lié au nombre limité de codets dans un jeu à sept bits. Ceci se retrouve notamment dans les symboles de ponctuation et l'utilisation des guillemets. L'ASCII a été conservé parce qu'il est omniprésent dans de nombreux logiciels. Cet héritage se retrouve dans Unicode ou ces signes sont dans un bloc disjoint des autres symboles similaires, se trouvant pour la plupart codés à partir de U+2000[6].

Internationalisation[ modifier | modifier le code ]

Les limites du standard américain ASCII ont conduit, sur trois périodes différentes, à trois approches de l'internationalisation :

  • L'utilisation de standards régionaux à caractères-monooctets, techniquement les plus faciles à mettre en place ;
  • L'utilisation de standards extensibles, où un même octet peut représenter un caractère différent suivant le contexte (famille ISO 2022) ainsi que des extensions où un caractère est codé sur plusieurs octets ;
  • L'utilisation du Standard Unicode (famille UTF), qui est celui qui comprend le plus grand nombre de caractères.

Les standards régionaux ont l'inconvénient de ne permettre la représentation que d'un ensemble réduit de caractères, comme les caractères d'Europe occidentale. Avec cette approche, il est nécessaire d'indiquer l'encodage à l'extérieur du flot.

Les standards ISO 2022 ont l'inconvénient d'être contextuels. Il se peut que des logiciels utilisant certains algorithmes de recherche manquent d'interopérabilité à cet égard.

Les formes de codage définies par le standard Unicode ont l'inconvénient de la présence éventuelle de la fonctionnalité d'indicateur d'encodage en début de flot, qui le cas échéant est introduit par le caractère Byte Order Mark. Certains logiciels anciens ne sont pas compatibles avec la présence de ces trois octets, et ne pourront pas l'être en raison de la complexité conceptuelle que représente le fait de traiter ces trois octets. En particulier, certaines opérations deviennent plus complexes comme la concaténation de chaînes.

Standardisation[ modifier | modifier le code ]

Le jeu de codage ASCII est défini quasiment identiquement par plusieurs standards différents, a de nombreuses variantes et a donné naissance à une foison (des dizaines ou des centaines) d'extensions plus ou moins incompatibles entre elles.

Les principales extensions sont justifiées par le fait que l'ASCII ne répond pas aux divers besoins régionaux. Elles sont proposées par des organismes de normalisation, ou par des fournisseurs de produits et de services.

Les standards ASCII[ modifier | modifier le code ]

Note: ne pas confondre USASI X3.4-1968 ou ANSI X3.4-1968 et ANSI X3.4:1986

Normes définissant ou ayant défini ce système de codage des caractères:

  • Les standards ASCII des États-Unis (les standards hérités, et le standard en vigueur)
    • ASA X3.4-1963, (incomplet avec 28 positions libres, et un code de commande non assigné)
    • USASI X3.4-1967, (renommé rétroactivement ANSI X3.4-1967); ne normalisait pas encore toutes les positions.
    • USASI X3.4-1968, (renommé rétroactivement ANSI X3.4-1968); ne normalisait pas encore toutes les positions.
    • ANSI X3.4-1977,
    • ANSI X3.4:1986 (en 1986, et en vigueur aujourd'hui)

Les standards internationaux suivants sont généralement considérés compatibles (quasi-identiques) avec le standard ASCII en vigueur de 1986 à 2011, tout en constituant une normalisation internationale officielle:

  • Norme ISO/CEI 646
    • ISO/CEI 646-US Variante des États-Unis
    • Variante IRV internationale
  • Code page IBM 367.
  • Alphabet International de Référence
    • Alphabet International de Référence no 5 (de 1988)[7].
    • Alphabet International de référence no 5 (dans le jeu G0 de l'IRV)[8].

La désignation US-ASCII ou ASCII é-u, ASCII des États-Unis est un mix des désignations précédentes. Le registre IANA lui attribue la dénomination US-ASCII, sans en définir le codage.

Approximation, variantes et extensions[ modifier | modifier le code ]

  • Norme ISO/CEI 646
    • Variante INV invariable (incomplète par rapport aux deux précédentes)

Trois types de codages de caractères se rapprochent de l'ASCII :

  • ceux qui ne changent que par la dénomination ; ils sont essentiellement identiques à l'ASCII
  • ceux qui sont des variantes, l'ASCII étant à l'origine la variante locale aux États-Unis de l'ISO 646
  • ceux qui l'augmentent, dits extensions

Alias[ modifier | modifier le code ]

En juin 1992, le RFC[9] et la chambre d'enregistrement de jeux de caractères Internet Assigned Numbers Authority [10] ont reconnu les alias insensibles à la casse suivants convenables pour l'utilisation dans des protocoles internet :
  • ANSI_X3.4-1968 (canonical name)
  • iso-ir-6
  • ANSI_X3.4-1986
  • ISO_646.irv:1991
  • ASCII (with ASCII-7 and ASCII-8 variants)
  • ISO646-US
  • US-ASCII (preferred MIME name)[10]
  • us
  • IBM367
  • cp367
  • csASCII

L'IANA promeut plus particulièrement la dénomination « US-ASCII » pour Internet.

Variantes[ modifier | modifier le code ]

Article détaillé : ISO/CEI 646.

ASCII a donné naissance à certaines variantes de l’ASCII qui conservent la plupart des caractères mais en remplacent certains. Dès lors, il ne s’agit plus d’ASCII à strictement parler.

Huitième bit et augmentations[ modifier | modifier le code ]

Article détaillé : ASCII étendu.

De nombreuses normes de codage de caractères ont repris les codes ASCII et ajouté d’autres caractères pour les codes supérieurs à 127.

Extensions mono-octets[ modifier | modifier le code ]

En particulier, beaucoup de pages de codes étendent l'ASCII en utilisant le 8e bit pour définir des caractères numérotés de 128 à 255. La norme ISO/CEI 8859 fournit des extensions pour diverses langues. Par exemple, l’ISO 8859-1, aussi appelée Latin-1, étend l’ASCII avec les caractères accentués utiles aux langues originaires d’Europe occidentale comme le français ou l’allemand.

Par abus de langage, on appelle souvent « ASCII » des normes qui étendent ASCII, mais qui ne sont pas compatibles entre elles (et parfois même ne sont pas compatibles sur leurs 128 premiers caractères codés). En particulier, les standards Windows-1252 (couramment utilisé sur Microsoft Windows dans les pays occidentaux), ISO 8859-1 (couramment utilisé sur Internet et UNIX) et les pages de code pour PC numéro 437 et 850 (couramment utilisées sur DOS) ne sont pas la norme ASCII. Cet abus de langage ne va pas sans causer des confusions causant des incompatibilités, souvent rendues visibles par le fait que les caractères non ASCII comme les « lettres accentuées » (éÈç) s'affichent mal. On écrit parfois ASCII de base pour bien identifier ASCII, et pas un standard plus étendu.

Extensions asiatiques, à base de séquences d'échappement[ modifier | modifier le code ]

Afin d’unifier les différents codages de caractères complétant l'ASCII et y intégrer les codages complètement différents (le JIS pour le japonais par exemple, qui bien que développé aussi sur la base de l’US-ASCII, en diffère dans l’assignation d’un des 128 premiers codets), la norme ISO/CEI 10646 a été inventée (et aussi développée au départ séparément par le Consortium Unicode dans une version de sa norme Unicode 1.0 initialement incompatible avec ISO/CEI 10646.

Voir notamment ISO 2022.

Extensions Unicode[ modifier | modifier le code ]

La version 1.0 a été abandonnée depuis la version 1.1 afin d’unifier et fusionner les deux répertoires dans un jeu universel de caractères codés). ISO/CEI 10646 codifie des dizaines de milliers de caractères, mais les 128 premiers restent compatibles avec ASCII (dans sa dernière version X3.4-1986) ; la norme Unicode y ajoute des sémantiques supplémentaires.

Toutefois, certains pays d’Asie orientale (la République populaire de Chine, les anciens dominions britannique et portugais en Chine, de Hong Kong et Macao, qui sont devenus depuis des régions administratives spéciales de Chine, la République de Chine à Taïwan, et le Japon) ont choisi de continuer à développer leur propre norme pour coder le jeu de caractères universel, tout en choisissant de les maintenir entièrement convertibles avec l’ISO/CEI 10646 ; parmi ces normes asiatiques, seule la norme nationale japonaise continue à maintenir une différence dans ses 128 premières positions avec le jeu ASCII, en codant le symbole monétaire du yen à la place de la barre oblique inversée (comme c’est aussi le cas dans la variante japonaise de la norme ISO/CEI 646).

Parmi les nombreuses extensions 8 bits de l'ASCII, le Multinational Character Set créé par Digital Equipment Corporation pour le terminal informatique VT220 est considéré comme à la fois l'ancêtre de l'ISO 8859-1 et de l'Unicode[11].

Influence[ modifier | modifier le code ]

L'ASCII a eu une influence importante dans le monde informatique. En particulier il a pendant longtemps limité les caractères disponibles aux caractères latins non accentués, notamment dans le monde de l'internet, que ce soit pour les noms de domaine, les adresses de courrier électronique, les caractères disponibles dans le Bios, ou les caractères dans lesquels peuvent être écrits des programmes informatiques.

Description[ modifier | modifier le code ]

Table des 128 caractères ASCII[ modifier | modifier le code ]

Table de correspondance ASCII

Dans la table suivante, les 33 caractères de contrôle (codes 0 à 31 et 127) sont présentés avec leur nom en anglais suivi d'une traduction entre parenthèses.

Code en base |  |  |  | Caractère | Signification
10 | 8 | 16 | 2
0 | 0 | 00 | 0000000 | NUL | Null (nul)
1 | 01 | 01 | 0000001 | SOH | Start of Header (début d'en-tête)
2 | 02 | 02 | 0000010 | STX | Start of Text (début du texte)
3 | 03 | 03 | 0000011 | ETX | End of Text (fin du texte)
4 | 04 | 04 | 0000100 | EOT | End of Transmission (fin de transmission)
5 | 05 | 05 | 0000101 | ENQ | Enquiry (End of Line) (demande, fin de ligne)
6 | 06 | 06 | 0000110 | ACK | Acknowledge (accusé de réception)
7 | 07 | 07 | 0000111 | BEL | Bell (caractère d'appel)
8 | 010 | 08 | 0001000 | BS | Backspace (espacement arrière)
9 | 011 | 09 | 0001001 | HT | Horizontal Tab (tabulation horizontale)
10 | 012 | 0A | 0001010 | LF | Line Feed (saut de ligne)
11 | 013 | 0B | 0001011 | VT | Vertical Tab (tabulation verticale)
12 | 014 | 0C | 0001100 | FF | Form Feed (saut de page)
13 | 015 | 0D | 0001101 | CR | Carriage Return (retour chariot)
14 | 016 | 0E | 0001110 | SO | Shift Out (fin d'extension)
15 | 017 | 0F | 0001111 | SI | Shift In (démarrage d'extension)
16 | 020 | 10 | 0010000 | DLE | Data Link Escape
17 | 021 | 11 | 0010001 | DC1 | Device Control 1 à 4 (DC1 et DC3 sont généralementutilisés pour coder XON et XOFF dans un canal de communication duplex)
18 | 022 | 12 | 0010010 | DC2
19 | 023 | 13 | 0010011 | DC3
20 | 024 | 14 | 0010100 | DC4
21 | 025 | 15 | 0010101 | NAK | Negative Acknowledge (accusé de réception négatif)
22 | 026 | 16 | 0010110 | SYN | Synchronous Idle
23 | 027 | 17 | 0010111 | ETB | End of Transmission Block (fin du bloc de transmission)
24 | 030 | 18 | 0011000 | CAN | Cancel (annulation)
25 | 031 | 19 | 0011001 | EM | End of Medium (fin de support)
26 | 032 | 1A | 0011010 | SUB | Substitute (substitution)
27 | 033 | 1B | 0011011 | ESC | Escape (échappement)
28 | 034 | 1C | 0011100 | FS | File Separator (séparateur de fichier)
29 | 035 | 1D | 0011101 | GS | Group Separator (séparateur de groupe)
30 | 036 | 1E | 0011110 | RS | Record Separator (séparateur d'enregistrement)
31 | 037 | 1F | 0011111 | US | Unit Separator (séparateur d'unité)
32 | 040 | 20 | 0100000 | SP | Espace (Space en anglais)
33 | 041 | 21 | 0100001 | ! | Point d'exclamation
34 | 042 | 22 | 0100010 | " | Guillemet droit
35 | 043 | 23 | 0100011 | # | Croisillon ou dièse ou signe numéro[8]
36 | 044 | 24 | 0100100 | $ | Dollar
37 | 045 | 25 | 0100101 | % | Pourcent
38 | 046 | 26 | 0100110 | & | Esperluette ou perluète[8]
39 | 047 | 27 | 0100111 | ' | Apostrophe ou guillemet fermant simple ou accent aigu[12]
40 | 050 | 28 | 0101000 | ( | Parenthèse ouvrante
41 | 051 | 29 | 0101001 | ) | Parenthèse fermante
42 | 052 | 2A | 0101010 | * | Astérisque
43 | 053 | 2B | 0101011 | + | Plus
44 | 054 | 2C | 0101100 | , | Virgule
45 | 055 | 2D | 0101101 | - | Moins ou tiret[8] ou trait d'union
46 | 056 | 2E | 0101110 | . | Point
47 | 057 | 2F | 0101111 | / | Barre oblique (Slash en anglais)
48 | 060 | 30 | 0110000 | 0 | Le chiffre zéro
49 | 061 | 31 | 0110001 | 1 | Le chiffre un
50 | 062 | 32 | 0110010 | 2 | Le chiffre deux
51 | 063 | 33 | 0110011 | 3 | Le chiffre trois
52 | 064 | 34 | 0110100 | 4 | Le chiffre quatre
53 | 065 | 35 | 0110101 | 5 | Le chiffre cinq
54 | 066 | 36 | 0110110 | 6 | Le chiffre six
55 | 067 | 37 | 0110111 | 7 | Le chiffre sept
56 | 070 | 38 | 0111000 | 8 | Le chiffre huit
57 | 071 | 39 | 0111001 | 9 | Le chiffre neuf
58 | 072 | 3A | 0111010 | : | Deux-points
59 | 073 | 3B | 0111011 | ; | Point-virgule
60 | 074 | 3C | 0111100 | < | Inférieur
61 | 075 | 3D | 0111101 | = | Égal
62 | 076 | 3E | 0111110 | > | Supérieur
63 | 077 | 3F | 0111111 | ? | Point d'interrogation
64 | 0100 | 40 | 1000000 | @ | Arobace ou arobase ou A commercial[8]
65 | 0101 | 41 | 1000001 | A |
66 | 0102 | 42 | 1000010 | B |
67 | 0103 | 43 | 1000011 | C |
68 | 0104 | 44 | 1000100 | D |
69 | 0105 | 45 | 1000101 | E |
70 | 0106 | 46 | 1000110 | F |
71 | 0107 | 47 | 1000111 | G |
72 | 0110 | 48 | 1001000 | H |
73 | 0111 | 49 | 1001001 | I |
74 | 0112 | 4A | 1001010 | J |
75 | 0113 | 4B | 1001011 | K |
76 | 0114 | 4C | 1001100 | L |
77 | 0115 | 4D | 1001101 | M |
78 | 0116 | 4E | 1001110 | N |
79 | 0117 | 4F | 1001111 | O |
80 | 0120 | 50 | 1010000 | P |
81 | 0121 | 51 | 1010001 | Q |
82 | 0122 | 52 | 1010010 | R |
83 | 0123 | 53 | 1010011 | S |
84 | 0124 | 54 | 1010100 | T |
85 | 0125 | 55 | 1010101 | U |
86 | 0126 | 56 | 1010110 | V |
87 | 0127 | 57 | 1010111 | W |
88 | 0130 | 58 | 1011000 | X |
89 | 0131 | 59 | 1011001 | Y |
90 | 0132 | 5A | 1011010 | Z |
91 | 0133 | 5B | 1011011 | [ | Crochet ouvrant
92 | 0134 | 5C | 1011100 | \ | Barre oblique inversée (backslash ou antislash en anglais)
93 | 0135 | 5D | 1011101 | ] | Crochet fermant
94 | 0136 | 5E | 1011110 | ^ | Accent circonflexe (avec chasse)
95 | 0137 | 5F | 1011111 | _ | Tiret bas ou trait bas[8] ou souligné (underscore en anglais)
96 | 0140 | 60 | 1100000 | ` | Accent grave (avec chasse)[13]
97 | 0141 | 61 | 1100001 | a |
98 | 0142 | 62 | 1100010 | b |
99 | 0143 | 63 | 1100011 | c |
100 | 0144 | 64 | 1100100 | d |
101 | 0145 | 65 | 1100101 | e |
102 | 0146 | 66 | 1100110 | f |
103 | 0147 | 67 | 1100111 | g |
104 | 0150 | 68 | 1101000 | h |
105 | 0151 | 69 | 1101001 | i |
106 | 0152 | 6A | 1101010 | j |
107 | 0153 | 6B | 1101011 | k |
108 | 0154 | 6C | 1101100 | l |
109 | 0155 | 6D | 1101101 | m |
110 | 0156 | 6E | 1101110 | n |
111 | 0157 | 6F | 1101111 | o |
112 | 0160 | 70 | 1110000 | p |
113 | 0161 | 71 | 1110001 | q |
114 | 0162 | 72 | 1110010 | r |
115 | 0163 | 73 | 1110011 | s |
116 | 0164 | 74 | 1110100 | t |
117 | 0165 | 75 | 1110101 | u |
118 | 0166 | 76 | 1110110 | v |
119 | 0167 | 77 | 1110111 | w |
120 | 0170 | 78 | 1111000 | x |
121 | 0171 | 79 | 1111001 | y |
122 | 0172 | 7A | 1111010 | z |
123 | 0173 | 7B | 1111011 | { | Accolade ouvrante
124 | 0174 | 7C | 1111100 | | | Barre verticale
125 | 0175 | 7D | 1111101 | } | Accolade fermante
126 | 0176 | 7E | 1111110 | ~ | Tilde
127 | 0177 | 7F | 1111111 | DEL | Delete (effacement)

On peut aussi présenter la table des caractères ASCII sous cette forme plus condensée qui met en évidence une organisation fondée sur la base 16.

PDF : fr en
 v · d · m
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
000
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
001
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
002
SP
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/
003
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
004
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
005
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
006
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
007
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
DEL

Caractères de contrôle[ modifier | modifier le code ]

NUL[ modifier | modifier le code ]

Originellement une NOP, un caractère à ignorer. Lui donner le code 0 permettait de prévoir des réserves sur les bandes perforées en laissant des zones sans perforation pour insérer de nouveaux caractères a posteriori. Avec le développement du langage C il a pris une importance particulière quand il a été utilisé comme indicateur de fin de chaîne de caractères.

SOH[ modifier | modifier le code ]

Start of heading : début d'en-tête. Il est aujourd'hui souvent utilisé dans les communications séries pour permettre la synchronisation après erreur[14].

DEL[ modifier | modifier le code ]

Delete : effacement. Lui donner le code 127 (1111111 en binaire) permettait de supprimer a posteriori un caractère sur les bandes perforées qui codaient les informations sur 7 bits. N'importe quel caractère pouvait être transformé en DEL en complétant la perforation des 7 bits qui le composaient.

LF, CR, fin de ligne[ modifier | modifier le code ]

Dans un fichier texte, la fin d'une ligne est représentée par un ou deux caractères de contrôle. Plusieurs conventions existent :

  • sur les systèmes Multics, Unix, Type Unix (Linux, AIX, Xenix, Mac OS X, etc.), BeOS, AmigaOS, RISC OS entre autres, la fin de ligne est indiquée par un saut de ligne (LF) ;
  • sur les machines Apple II et Mac OS jusqu'à la version 9, la fin de ligne est indiquée par un retour chariot (CR) ;
  • sur les systèmes DEC, RT-11 et généralement tous les premiers systèmes non-Unix et non-IBM, CP/M, MP/M, MS-DOS, OS/2 ou Microsoft Windows, la fin de ligne est indiquée par un retour chariot suivi d'un saut de ligne (CR suivi de LF).

Ainsi, lorsqu'on transfère un fichier ASCII entre des systèmes ayant des conventions de fin de ligne différentes, il faut convertir les fins de ligne pour pouvoir le manipuler confortablement sur le système cible. Autrement, il faut utiliser un éditeur de texte capable de gérer les diverses conventions de fin de ligne, ce qui n'est par exemple pas le cas du classique Bloc-notes de Microsoft Windows. Les programmes utilisant les fichiers ASCII ne sont en général pas perturbés par un changement de type de fin de ligne.

SUB[ modifier | modifier le code ]

Il est souvent associé à la combinaison de touche Contrôle + z, et est utilisé dans les communications séries pour permettre l'envoi des données en lieu et place de la touche entrée.

Voir aussi[ modifier | modifier le code ]

Notes et références[ modifier | modifier le code ]

  1. ? http://www.trailing-edge.com/~bobbemer/SURVEY.HTM [archive]
  2. ? http://discover.lib.umn.edu/cgi/f/findaid/findaid-idx?c=umfa;cc=umfa;rgn=main;view=text;didno=cbi00067 [archive]
  3. ? http://www.cs.tut.fi/~jkorpela/latin1/ascii-hist.html [archive]
  4. ? Appendix §A.6.8 de la norme de A963
  5. ? Becker Pascal, Histoire des supports informatiques (lire en ligne [archive])
  6. ? (fr) Unicode 5.0 en pratique, chapitre 7 « Ponctuation » [archive], Patrick Andries.
  7. ? Alphabet International de référence no 5, Union international des télécommunications,? 1988 (lire en ligne [archive])
  8. ? a, b, c, d, e et f Alphabet International de référence : ANCIEN ALPHABET INTERNATIONAL no 5 ou AI5, Union international des télécommunications,? 1992 (lire en ligne [archive])
  9. ? (en) Rationel Almen Planlaegning, Request for Comments: 1345 : Character Mnemonics & Character Sets, Network Working Group,? juin 1992 (RFC 1345 [archive]).
  10. ? a et b Internet Assigned Numbers Authority (May 14, 2007). "Character Sets [archive]". Accessed 2008-04-14.
  11. ? Roman Czyborra, « ISO 8859-1 and MCS, from ISO 8859 Alphabet Soup » [archive]
  12. ? La norme ANSI X3.4 définit le caractère 39 par apostrophe (closing single quotation mark, acute accent) et les anciennes tables de caractères le représentaient souvent incliné. Les encodages plus récents restreignent ce code à la représentation de l'apostrophe verticale (ni penchée à droite, ni à gauche, mais neutre). Voir (en) Latin-1's apostrophe, grave accent, acute accent [archive].
  13. ? Le code 96 est également employé comme guillemet ouvrant simple en ASCII. En Unicode, il existe un code plus approprié.
  14. ? (en) ASCII character set [archive]

Bibliographie[ modifier | modifier le code ]

  • (en) Business Equipment Manufacturer Associations, American Standard Code for Information Interchange : ASA standard X3.4-1963, American Standards Asociation Incorporated,? 17 juin 1963 (lire en ligne)
  • (en) Eric Fischer, The Evolution of Character Codes, 1874-1968, .transbay.net (lire en ligne)

Articles connexes[ modifier | modifier le code ]

  • Art ASCII
  • ASCII porn
  • Fichier texte
  • Vidéotex
  • libcaca : bibliothèque permettant des rendus ASCII à partir de vidéos
  • Unicode
[afficher]
v · d · m
Jeux de caractères codés
Multi-octets
Unicode | ISO/CEI 10646 · Table des caractères Unicode · UTF-8 · UTF-16 · UTF-32 · UTF-EBCDIC · CESU-8 · BOCU-1
Autres | ISO/CEI 2022 · Big5 · ISCII · GB 18030 · GBK · Shift-JIS · Codage des caractères chinois
Codage Baudot
Codés sur 8 bits
ISO/CEI 8859 | -1 (Latin-1) · -2 (Latin-2) · -3 (Latin-3) · -4 (Latin-4) · -5 (Cyrillique) · -6 (Arabe) · -7 (Grec) · -8 (Hébreu) · -9 (Latin-5) · -10 (Latin-6) · -11 (Thaï) · -12 (Devanagari) · -13 (Latin-7) · -14 (Latin-8) · -15 (Latin-9) · -16 (Latin-10)
Pages de code Windows | 874 / TIS-620 · 932 / Shift JIS · 936 / GBK · 949 / EUC-KR · 950 / Big5 · 1250 · 1251 · 1252 · 1253 · 1254 · 1255 · 1256 · 1257 · 1258 · 54936 / GB18030
Pages de code Mac OS | MacRoman
Pages de code DOS | 437 · 720 · 737 · 775 · 850 · 852 · 855 · 857 · 858 · 860 · 861 · 862 · 863 · 864 · 865 · 866 · 869 · Kamenický · Mazovia · MIK · Iran System
Pages de code diverses | ANSEL · DEC-MCS · KOI8-R (russe) · KOI8-U (ukrainien) · StandardEncoding (PostScript) · Page de code vidéotex · Page de code ZX Spectrum · Page de code Amstrad CPC · Page de code Atari ST · Page de code Amiga
Non basés sur ISO 646 | VISCII · EBCDIC · EBCDIC 297 · EBCDIC 8859
Autres
Codés sur 7 bits | ASCII · ISO 646
Moins de 7 bits | Code morse · Code wabun · Code Baudot · RADIX-50 · Sixbit
Codage des caractères · Clavier d’ordinateur · Police numérique · Glyphe · Mojibake · Portail:Écriture
[afficher] v · d · m Couches du modèle OSI
7. Application | BGP · DHCP · DNS · FTP · Gopher · H.323 · HTTP · IMAP · IRC · NFS · NNTP · POP3 · RTSP · SILC · SIMPLE · SIP · SMTP · SNMP · SMB-CIFS · SSH · TCAP · Telnet · TFTP · VoIP · XMPP · WebDAV
6. Présentation | AFP · ASCII · ASN.1 · MIME · NCP · SSP · TDI · TLV · Unicode · UUCP · Vidéotex · XDR
5. Session | AppleTalk · DTLS · H.323 · RSerPool · SOCKS · TLS
4. Transport | DCCP · RSVP · RTP · SCTP · SPX · TCP · UDP
3. Réseau | ARP · Babel · BOOTP · CLNP · ICMP · IGMP · IPv4 · IPv6 · IPX · IS-IS · NetBEUI · OSPF · RARP · RIP · X.25
2. Liaison | Anneau à jeton · ARINC 429 · ATM · AFDX · Bitnet · CAN · Ethernet · FDDI · Frame Relay · HDLC · I²C · IEEE 802.3ad (LACP) · IEEE 802.1aq (SPB) · LLC · LocalTalk · MIL-STD-1553 · PPP · STP · Wi-Fi · X.21
1. Physique | 4B5B · ADSL · BHDn · Bluetooth · Câble coaxial · Codage bipolaire · CSMA/CA · CSMA/CD · DSSS · E-carrier · EIA-232 · EIA-422 · EIA-449 · EIA-485 · FHSS · IEEE 1394 · HomeRF · IrDA · ISDN · Manchester · Manchester différentiel · Miller · MLT-3 · NRZ · NRZI · NRZM · Paire torsadée · PDH · SDH · SDSL · SONET · T-carrier · USB · VDSL · V.21-V.23 · V.42-V.90 · Wireless USB · 10BASE-T · 10BASE2 · 10BASE5 · 100BASE-TX · 1000BASE-T
Articles liés | Pile de protocoles · Modèle Internet
  • Portail de l’informatique Portail de l’informatique
  • Portail de l’écriture Portail de l’écriture

Ce document provient de « http://fr.wikipedia.org/w/index.php?title=American_Standard_Code_for_Information_Interchange&oldid=103030698 ».
Catégories :
  • Codage des caractères
  • Format ouvert
  • Protocole réseau sur la couche présentation
| [+]
Catégories cachées :
  • Article à référence nécessaire
  • Portail:Informatique/Articles liés
  • Portail:Écriture/Articles liés
  • Article de qualité en espagnol

Menu de navigation

Outils personnels

  • Créer un compte
  • Se connecter

Espaces de noms

  • Article
  • Discussion

Variantes

Affichages

  • Lire
  • Modifier
  • Modifier le code
  • Historique

Plus

Navigation

  • Accueil
  • Portails thématiques
  • Article au hasard
  • Contact

Contribuer

  • Débuter sur Wikipédia
  • Aide
  • Communauté
  • Modifications récentes
  • Faire un don

Imprimer / exporter

  • Créer un livre
  • Télécharger comme PDF
  • Version imprimable

Outils

  • Pages liées
  • Suivi des pages liées
  • Importer un fichier
  • Pages spéciales
  • Adresse de cette version
  • Information sur la page
  • Élément Wikidata
  • Citer cette page

Autres langues

  • Alemannisch
  • ???????
  • Asturianu
  • Az?rbaycanca
  • ?????????
  • ?????
  • Bosanski
  • Català
  • ?????
  • ?eština
  • Dansk
  • Deutsch
  • ????????
  • English
  • Esperanto
  • Español
  • Eesti
  • Euskara
  • ?????
  • Suomi
  • Gaeilge
  • Galego
  • ?????
  • ??????
  • Hrvatski
  • Magyar
  • Interlingua
  • Bahasa Indonesia
  • Italiano
  • ???
  • Taqbaylit
  • ???????
  • ???
  • Kurdî
  • Lëtzebuergesch
  • Lietuvi?
  • Latviešu
  • ???? ?????
  • ??????
  • ??????
  • ?????
  • Bahasa Melayu
  • Plattdüütsch
  • ????? ????
  • Nederlands
  • Norsk nynorsk
  • Norsk bokmål
  • Occitan
  • Polski
  • Português
  • Român?
  • ???????
  • Scots
  • Srpskohrvatski / ??????????????
  • Simple English
  • Sloven?ina
  • Slovenš?ina
  • Shqip
  • ?????? / srpski
  • Svenska
  • ?????
  • ??????
  • ???
  • Türkçe
  • ??????????
  • ????
  • O?zbekcha
  • Ti?ng Vi?t
  • ??????
  • Yorùbá
  • ??
  • Bân-lâm-gú
  • ??
Modifier les liens
  • Dernière modification de cette page le 18 avril 2014 à 23:12.
  • Droit d'auteur : les textes sont disponibles sous licence Creative Commons paternité partage à l’identique ; d’autres conditions peuvent s’appliquer. Voyez les conditions d’utilisation pour plus de détails, ainsi que les crédits graphiques. En cas de réutilisation des textes de cette page, voyez comment citer les auteurs et mentionner la licence.
    Wikipedia® est une marque déposée de la Wikimedia Foundation, Inc., organisation de bienfaisance régie par le paragraphe 501(c)(3) du code fiscal des États-Unis.
  • Politique de confidentialité
  • À propos de Wikipédia
  • Avertissements
  • Développeurs
  • Version mobile
  • Powered by MediaWiki


Art ASCII — Wikipédia

Art ASCII

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Cet article est une ébauche concernant l’informatique.
Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

_________________________________________________
|             _       _    ____   ____ ___ ___  |
|   __ _ _ __| |_    / \  / ___| / ___|_ _|_ _| |
|  / _` | '__| __|  / _ \ \___ \| |    | | | |  |
| | (_| | |  | |_  / ___ \ ___) | |___ | | | |  |
|  \__,_|_|   \__|/_/   \_\____/ \____|___|___| |
|_______________________________________________|

L'art ASCII consiste à réaliser des images uniquement à l'aide des lettres et caractères spéciaux contenus dans le code
Pour info beacoup de programmeurs d'USA utilise les symboles du code ascii pour dessiner (voir les doc. et readme.txt en mode réel) J2M. ASCII.

Sommaire

  • 1 Description
  • 2 Types et exemples d'art ASCII
  • 3 Notes et références
  • 4 Voir aussi
    • 4.1 Articles connexes

Description[ modifier | modifier le code ]

Cette pratique a commencé avec les mainframes, où ce genre d'images permettait de montrer ce qu'il était possible de faire avec une imprimante bien menée. Les images étaient alors d'une largeur de 120 ou 132 caractères pour une longueur variable, et autorisaient les superpositions multiples de caractères. Une image de ce type très répandue dans les années 1960 était un portrait de Brigitte Bardot. Des machines couplées à des caméras vidéo imprimèrent par la suite des portraits sur papier dans des galeries commerciales (parfois aussi sur des T-shirts par une méthode de transfert).

La pratique s'est plus tard répandue par le biais des premiers BBS, sur lesquels il n'était pas possible d'afficher autre chose que du texte. La superposition de caractères disparut à mesure que les écrans remplaçaient les terminaux de type machine à écrire.

À partir des années 1980, certains artistes ont utilisé des jeux de caractères étendus tels que la page de code 437, disponible en mode texte sur compatible PC.

On peut réaliser de l'art ASCII avec un simple éditeur de texte à l'aide d'une police de caractères à chasse fixe (par exemple : Courrier New), mais il existe des logiciels automatisant le processus, à l'aide d'algorithmes de conversion d'image en texte. Évidemment ces images, si elles sont faites à la main, demandent beaucoup de temps et de talent, d'où le terme « art ».

Types et exemples d'art ASCII[ modifier | modifier le code ]

Article détaillé : Émoticône.

La forme la plus simple d'art ASCII est la combinaison de deux ou trois caractères pour exprimer une émotion en texte. Effectuez mentalement la rotation de 90° de ces exemples pour une orientation plus compréhensible de ceux-ci, ou penchez la tête à gauche.

             :-) ou  :) ou =) sourire
             :-( ou  :( ou =( triste
             :'(             pleure
            ;-) ou ;)       clin d'œil
             :-D ou  :D ou =D rire
            XD              mort de rire (paupières serrées)
             :-P ou  :P ou =P tire la langue
            B-) ou 8-)      cool (lunettes de soleil)
            Xo              souffrant
             :')             pleure de joie
             :S              malade, gêné

Il y a un autre type d'art ASCII en une ligne qui ne nécessite pas de rotation. Ils sont parfois appelés « smileys japonais ». Exemples :

       (^_^)         (Smiley homme)

        d~.~b        (Écoute au casque)

        \(^o^)/      (Youpi ! / Panique)

   (o.~) ou ^_-      (Clin d'œil)

          ^_^        (Content)

         (-_-)ZZZ    (Dort)

         ``(ToT)´´   (Pleure)

         (?_?)       (Confus)

         (^.^)       (Smiley femme)

          -_-        (Fatigué, accusateur ou exaspéré)

          x_x        (Mort)

 (_)_TNT___)------*  (TNT)

          -_-'       (Gêné - par quelqu'un)

         (*^_^*)     (Rougit, timide)

        -`(0_o)´- ou  O_o   (Impressionné et/ou confus et/ou choqué)

     (!_!) / (o_o)   (Choqué)

Il est également possible de représenter des animaux et des silhouettes :

     >(°< °)<  ou  \_/o<  (Oiseau)

           <:3))))~~      (Souris, rat)

            >##\°)        (Poisson)

          \o/  (Victoire : silhouette bras levés)

          _o/  (Adieux ou salutation : silhouette un bras levé)

          /o\  (Consternation : tête dans les mains)

Et une « image ASCII (étendu...) de Freud[1] », plus évocatrice en police sérif, de son célèbre portrait de 1926 par Ferdinand Schmutzer : [ ( `;-£›‹>??•?\ ]
datée du début des années 2000.

Ensuite il existe des figures plus complexes, qui nécessitent plusieurs lignes :

                  (_) |  (_)              | (_)
 () ()   __      ___| | ___ _ __   ___  __| |_  __ _
 (-.-)   \ \ /\ / / | |/ / | '_ \ / _ \/ _` | |/ _` |
 (   )    \ V  V /| |   <| | |_) |  __/ (_| | | (_| |
(") (")o   \_/\_/ |_|_|\_\_| .__/ \___|\__,_|_|\__,_|
                           | |
                           |_|

          _..-/  /  |  \    \   _|/|
         \      /-./_ \;   \    \,;'   \
         ,\    / \:  `:\    \   //    `:`.
       ,'  \  /-._;   |  :     :  ::    ,.   .
     ,'      ::   /`-._| |    | || '  :  `.`.)
  _,'       |;._:: |  | |    | `|    :    `'
,'   `.     /   |`-:_ ; |    |  |   : \
`--.   )   /|-._:     :          |   \ \
   /  /    :_|   ;`-._;   __..--';     :  :
  /  (    ;|;-./_  _/.-:'o |   /     ' |
 /  , \._/_/_./--/_|:|___|_,'        | |
:  /   `'-'--'----'---------'          |
|  :     O ._O   O_. O ._O   O_.      ; ;     Un bateau viking (drakkar)
: `.      //    //    //    //     ,' /

/\_/\___  _   /__   \_   _| |__   ___
\_ _/ _ \| | | |/ /\/ | | | '_ \ / _ \
 / \ (_) | |_| / /  | |_| | |_) |  __/
 \_/\___/ \__,_\/    \__,_|_.__/ \___| Logo youtube
           (__)
           (oo)                                                     \                 (\_/) (\___/)
    /-------\/      __        O             \O/          (\___/)     \ /\     ()_()   (^_^) (='.'=)    _[ ]_
   / |     ||      /o)\      /|\             |           (='.'=)     ( )     (='.'=)  (>$<) ( U U )   \('o')/
  *  ||----||      \(o/      / \            / \          (")_(")   .( o ).   (")_(")  (/ \) (")_(")    ( : )
     ~~    ~~
      Vache     Yin/Yang   Personne  Personne contente         Cinq exemples de lapins              Bonhomme de neige

Certaines personnes utilisent l'art ASCII comme signatures dans leurs courriels ou leurs posts sur des forums. Ce dessin qui ressemble à une vache est en fait un gnou. C'est un Easter Egg de apt-get, un gestionnaire de paquets pour certains systèmes GNU/Linux (prononcer "gnou/linux").

                 _a,
                _yQa.
               _qTWW(
               je`?QX:
              <d+ -3Wm;
             _qos_s%mWw,
             a2?????TWW(
            sd(     -?Qm;.
          .amm;     .xmWmc
          """""`    """""""

           \\\||||||////
            \\  ~ ~  //
             (  @ @  )
    ______ oOOo-(_)-oOOo___________
    .......
    .......
    .......
    _____________Oooo._____________
       .oooO     (   )
        (   )     ) /
         \ (     (_/
          \_)

Parfois on rencontre aussi des mots dont les lettres sont constituées d'elles-mêmes. C'est ainsi qu'étaient souvent composées les pages de garde des travaux d'impression sur les machines imprimant en continu des sorties de travaux batch.

      HHHHHH    HHHHHH    IIIIII     !!!
       HHHH      HHHH      IIII     !!!!!
       HHHH      HHHH      IIII     !!!!!
       HHHH      HHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII     !!!!!
       HHHHHHHHHHHHHH      IIII      !!!
       HHHH      HHHH      IIII
       HHHH      HHHH      IIII      !!!
       HHHH      HHHH      IIII     !!!!!
      HHHHHH    HHHHHH    IIIIII     !!!

On peut aussi s'en servir pour créer de la typographie, par exemple :

       ___              __,
      ( /              (          o _/_ /
       / __,  _   _     `.  _ _,    /  /_
     _/_(_/(_/ /_(/_  (___)/ / /_(_(__/ /_
    //
   (/

Voici un exemple d'art ASCII apparu sur Amiga. Ce genre d'art ASCII est fait à la main dans un éditeur de texte :

                   ______.----------------------------.______
                 :_)                                        (_:
             ....|:                                          :|....
             :  :<>                                          <>:  :
             :···|:                                          :|···:
         .---+- -:-                                          -:- -+---.
      /\___  |    /\___      /\_____     /\______     /\______    |   /\___
    _/    /  |  _/    /___ _/ __   /   _/  __   /   _/  __   /    : _/    /
    \  __//\ :/\\   _//  / \  )/  //\  \   )/  //\  \   )/  //\  /\ \_   //\
  _/¯¯ \)¯  \/  ¯¯ __¯   \/¯¯ ¯  ¯¯  \/¯¯  ¯_ ¯¯  \/¯¯  ¯_ ¯¯  \/  ¯)/  ¯¯  \_
  \                )/¯                     (/           (/          ¯        /
 /¯¯               /                       /            /            _      ¯¯\
 \_           /\__/        /\_        /\__/        /\__/         /\_(/       _/
 =/          /===/        /==/       /===/        /=©d/         /=:=/       /=
  ¯¯¯¯¯¯¯¯¯\/:   :¯¯¯¯¯¯\/   ¯¯¯¯¯¯\/    ¯¯¯¯¯¯¯\/    ¯¯¯¯¯¯¯¯\/  | ¯¯¯¯¯¯\/
   ______.---+-  :____ /\_____  :              :      ________:  -+---.______
 :_)·····    :.....  _/      /--+--./\_____.---+---./\___    .....:    ·····(_:
 |:           : ..:..\      /   : _/      /    :  _/    /  ..:.. :           :|
 <>           :.:.: : \  __//\  /\\  __  //\  /\  \_   //\ : :.:.:           <>
 |:             :..._/¯¯ \)¯  \/  ¯¯ )/ ¯¯  \/  ¯¯)/  ¯¯  \_...:             :|
 :        ____ ____ \                ¯            ¯        / ____ ____        :
 \_.     _\_  \\  //¯¯                            _       ¯¯\\  //  _/_     ._/
 ---· _  \¯ _  \\ \\_           /\_           /\_(/        _// //  _ ¯/  _ ·---
 /¯·  \¯¯¯ ¯\¯¯¯ ¯¯=/          /:=/          /=:=/        /= ¯¯ ¯¯¯/¯ ¯¯¯/  ·¯\
 :     ¯¯¯¯¯¯       ¯¯¯¯¯¯¯¯¯\/-+--¯¯¯¯¯¯¯¯\/--+--¯¯¯¯¯¯\/         ¯¯¯¯¯¯    :
 |:                             :              :                             :|
 <>                          .              .                                <>
 |:                      _ . | __ .__.__   .|__  __    .                     :|
 :¯).....             __(__|-|(_/_| (| ((__||__)(__)(__|__             .....(¯:
   ¯¯¯¯¯¯·-----------·-------|----|--|----(/----------(/--·-----------·¯¯¯¯¯¯

Voici Tux, le manchot mascotte du système d'exploitation GNU/Linux :

            .-"""-.
           '       \
          |,.  ,-.  |
          |()L( ()| |
          |,'  `".| |
          |.___.',| `
         .j `--"' `  `.
        / '        '   \
       / /          `   `.
      / /            `    .
     / /              l   |
    . ,               |   |
    ,"`.             .|   |
 _.'   ``.   o     | `..-'l
|       `.`,        |      `.
|         `.    __.j         )
|__        |--""___|      ,-'
   `"--...,+""""   `._,.-' mh

De nos jours l'art ASCII est rarement réalisé à la main, mais plutôt par des logiciels qui facilitent la création d'œuvres de plus en plus complexes.
Voici par exemple un smiley réalisé en art ascii.

                          oooo$$$$$$$$$$$$oooo
                      oo$$$$$$$$$$$$$$$$$$$$$$$$o
                   oo$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o         o$   $$ o$
   o $ oo        o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o       $$ $$ $$o$
oo $ $ "$      o$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$o       $$$o$$o$
"$$$$$$o$     o$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$o    $$$$$$$$
  $$$$$$$    $$$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$
  $$$$$$$$$$$$$$$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$$$$$$  """$$$
   "$$$""""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$
    $$$   o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$o
   o$$"   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$       $$$o
   $$$    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" "$$$$$$ooooo$$$$o
  o$$$oooo$$$$$  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$   o$$$$$$$$$$$$$$$$$
  $$$$$$$$"$$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$""""""""
 """"       $$$$    "$$$$$$$$$$$$$$$$$$$$$$$$$$$$"      o$$$
            "$$$o     """$$$$$$$$$$$$$$$$$$"$$"         $$$
              $$$o          "$$""$$$$$$""""           o$$$
               $$$$o                                o$$$"
                "$$$$o      o$$$$$$o"$$$$o        o$$$$
                  "$$$$$oo     ""$$$$o$$$$$o   o$$$$""
                     ""$$$$$oooo  "$$$o$$$$$$$$$"""
                        ""$$$$$$$oo $$$$$$$$$$
                                """"$$$$$$$$$$$
                                    $$$$$$$$$$$$
                                     $$$$$$$$$$"
                                      "$$$""

Certaines œuvres nécessitent presque de s'éloigner de l'écran ou de plisser les yeux pour apprécier le travail réalisé.

|JM/:::::::::J::::::::J::::::::::L|JMMMMMMMMMMMMMMMMM|
||M::::::::::F::::::::F::::J::::JMJFMMMMMMMMMMMMMMMMM|
J|F:::::;:::J::::::::/L::::FL:::LM'MMMMMMMMMMMMMMMMMM|
:`:::::/L:::|L::::::/M|:::JM|::/MMMMMMMMMMMMMMMMMMMMMF
:::::://::\:|J:::::JMM|:::FM|:/MMMMMMMMMMMMMMMMMMMMMM-
:;'::/J:::F\JM\::::FMMJ::JMM|/MMMMMMMMMMMMMMMMMMMMMMF
'.::/MMF:JMM\LM\::JMMMM\:|MM'MMMMMMMMMMMMMMMMMMMMMMM -
::;dMMM|:FMMM`MM\:|MMMMML|MMMMP"ooMMMMMMMMMMMMMMMMMF-
:/MMMMM|:MMMP"TTQ\LMMMMM|FMMP;\o#J__MMMMMMMMMMMMMMM  -
/MMMMMM|F-. |o#J__\  )MM'MP' `""""  QMMMMMMMMMMMMMF -
M/\MMMM/J  '-"""      J/ '          MMMMMMMMMMMMM/ - -
/::\MMMMML                J.       JMMMMMMMMMMMMM - -
\::::QMMMJ                CD;      MMMMMMMMMMMMMF- - -
:\:::::QMM\               J'      JMMMMMMMMMMMM/- - -
\:\::Lb:\MMb._                   /MMMMMMMMM/\M/- - - -
 \:\:JMMb\MM\"`-       .---     /MMMMMMMMM/ /'- - - -
- `(`:\MMMMMMb.                /MMMMMMMMP' - - - - - -
 - - -\\MMMMMMMb-             /MMP"QMMP'- - - - - - -
- - - -\\MMMJMMMb.          .dMMM|/MP' - - - - - - - -
 - - - -`\`Q|MMMMMbo._    .dMMMMMJ"'- - - - - - - - -
- - - - - - F`QMMMMMMMboodMMMMMMMML- - - - - - - - - -
 - - - - - J  ,`QMMMMMMMMMMMMMMMMMJ - - - - - - - - -
- - - - - -F  |o.\MMMMMMMMMMMMMMMMML - - - - - - - - -
 - - - - -J   FMMM\MMMMMMMMMMMMMMMMJ- - - - - - - - -
- - - - -/   /MMMMMb.MMMMMMMMMMMMMMM\- - - - - - - - -

          .   ,
       '. '.  \  \
      ._ '-.'. `\  \
        '-._; .'; `-.'.
       `~-.; '.       '.
        '--,`           '.
           -='.          ;
 .--=~~=-,    -.;        ;
 .-=`;    `~,_.;        /
`  ,-`'    .-;         |
   .-~`.    .;         ;
    .;.-   .-;         ,\
      `.'   ,=;     .-'  `~.-._
       .';   .';  .'      .'   '-.
          .\  ;  ;        ,.' _  a',
         .'~";-`   ;      ;"~` `'-=.)
       .' .'   . _;  ;',  ;
       '-.._`~`.'  \  ; ; :
            `~'    _'\\_ \\_
                  /=`^^=`""/`)-.
                  \ =  _ =     =\
                   `""` `~-. =   ;

Wikip  iaWi  pedia ikiped  Wikipe   Wik pediaW kipediaWik  ediaWikiped   ikipedi     pediaW       aWi
ipedi  ikip  iaWik pediaW  ipedi    ipe iaWiki  diaWikiped aWikipediaWi  pediaWiki   iaWiki      ikipe
 iaWi  pedi  ikip   aWik    iaW    ed    kipe   Wiki    aWikipe    ikip  iaWikipedi   kipe       pedia
  kip   aWi  ped     ipe    iki   ia      dia   ipediaWikip dia          ikip   aWik   dia      diaWik
  edi  ikip  ia      edi    pediaWi       aWi   diaWikiped  Wikipe        edi   kipe   aWi      Wik ped
   Wi  pediaWik      Wik    iaWikip       ipe   Wikipedia   ipediaW       aWi    dia   ipe     kipediaWi
   ipediaWikipe      ipe    ikipedi       dia   ipe         diaWiki       kip   aWik   dia     ediaWikip
    iaWikipedia      dia    ped  Wik      Wik   dia         Wik          pedi  ikipe   Wik    iaWi   edia
     kip  iaWi      aWik    iaW  ipe     kipe   Wik         iped    kip diaWikipedia  kipe    iki     Wik
      d   ikip     ikiped  Wikip diaWikipediaW kipedi      ediaWik pedi WikipediaWi  pediaW kipedi   kipedi
      Wi   ed      pediaWikipedi WikipediaWikipediaWi      aWikipediaWi ipediaWik    iaWikipediaWi   ediaWi

Notez que celui-ci est de l'ANSI ART, un dérivé de l'ASCII ART, car il a été teinté de gris. Les dégradés et gris typographique se font donc uniquement avec lettres, comme sur l'exemple suivant.

Le logo de Wikipédia en art ASCII (composé de 7857 caractères)

WP logo ASCII art 7857 chars.png

Notes et références[ modifier | modifier le code ]

  1. ? Plongées dans La Fontaine [1] [archive].

Voir aussi[ modifier | modifier le code ]

Articles connexes[ modifier | modifier le code ]

  • Calligramme
  • libcaca
  • FIGlet
  • Teehan+LaX
  • ASCII porn

  • Portail de l’informatique Portail de l’informatique
  • Portail des arts Portail des arts
Ce document provient de « http://fr.wikipedia.org/w/index.php?title=Art_ASCII&oldid=105438853 ».
Catégorie :
  • Art numérique
| [+]
Catégories cachées :
  • Wikipédia:ébauche informatique
  • Portail:Informatique/Articles liés
  • Portail:Arts/Articles liés

Menu de navigation

Outils personnels

  • Créer un compte
  • Se connecter

Espaces de noms

  • Article
  • Discussion

Variantes

Affichages

  • Lire
  • Modifier
  • Modifier le code
  • Historique

Plus

Navigation

  • Accueil
  • Portails thématiques
  • Article au hasard
  • Contact

Contribuer

  • Débuter sur Wikipédia
  • Aide
  • Communauté
  • Modifications récentes
  • Faire un don

Imprimer / exporter

  • Créer un livre
  • Télécharger comme PDF
  • Version imprimable

Outils

  • Pages liées
  • Suivi des pages liées
  • Importer un fichier
  • Pages spéciales
  • Adresse de cette version
  • Information sur la page
  • Élément Wikidata
  • Citer cette page

Autres langues

  • ???????
  • ?????
  • Català
  • ?eština
  • Dansk
  • Deutsch
  • English
  • Esperanto
  • Español
  • Eesti
  • ?????
  • Suomi
  • Galego
  • ?????
  • Hrvatski
  • Interlingua
  • Bahasa Indonesia
  • Italiano
  • ???
  • ???
  • Lietuvi?
  • Latviešu
  • Bahasa Melayu
  • Nederlands
  • Norsk nynorsk
  • Norsk bokmål
  • Polski
  • Português
  • ???????
  • Simple English
  • Sloven?ina
  • Slovenš?ina
  • ?????? / srpski
  • Svenska
  • ??????????
  • Ti?ng Vi?t
  • ??
Modifier les liens
  • Dernière modification de cette page le 14 juillet 2014 à 21:21.
  • Droit d'auteur : les textes sont disponibles sous licence Creative Commons paternité partage à l’identique ; d’autres conditions peuvent s’appliquer. Voyez les conditions d’utilisation pour plus de détails, ainsi que les crédits graphiques. En cas de réutilisation des textes de cette page, voyez comment citer les auteurs et mentionner la licence.
    Wikipedia® est une marque déposée de la Wikimedia Foundation, Inc., organisation de bienfaisance régie par le paragraphe 501(c)(3) du code fiscal des États-Unis.
  • Politique de confidentialité
  • À propos de Wikipédia
  • Avertissements
  • Développeurs
  • Version mobile
  • Powered by MediaWiki
mw.loader.state({"ext.globalCssJs.site":"ready","ext.globalCssJs.user":"ready","site":"loading","user":"ready","user.groups":"ready"}); }


ASCII Characters

ASCII Character Codes

This list is helpful with the Asc and Chr functions. Taken from ASCII Character Set

Control Characters (mostly non-printing; most useful of these are highlighted in yellow.)

Char... | Dec | Hex | Description
NUL | 0 | 00 | Null character
SOH | 1 | 01 | Start of heading, = console interrupt
STX | 2 | 02 | Start of text, maintenance mode on HP console
ETX | 3 | 03 | End of text
EOT | 4 | 04 | End of transmission, not the same as ETB
ENQ | 5 | 05 | Enquiry, goes with ACK; old HP flow control
ACK | 6 | 06 | Acknowledge, clears ENQ logon hand
BEL | 7 | 07 | Bell, rings the bell... (Plays Windows' default beep)
BS | 8 | 08 | Backspace, works on HP terminals/computers
HT | 9 | 09 | Horizontal tab, move to next tab stop
LF | 10 | 0a | Line Feed
VT | 11 | 0b | Vertical tab
FF | 12 | 0c | Form Feed, page eject
CR | 13 | 0d | Carriage Return
SO | 14 | 0e | Shift Out, alternate character set
SI | 15 | 0f | Shift In, resume default character set
DLE | 16 | 10 | Data link escape
DC1 | 17 | 11 | XON, with XOFF to pause listings; ":okay to send".
DC2 | 18 | 12 | Device control 2, block-mode flow control
DC3 | 19 | 13 | XOFF, with XON is TERM=18 flow control
DC4 | 20 | 14 | Device control 4
NAK | 21 | 15 | Negative acknowledge
SYN | 22 | 16 | Synchronous idle
ETB | 23 | 17 | End transmission block, not the same as EOT
CAN | 24 | 17 | Cancel line, MPE echoes !!!
EM | 25 | 19 | End of medium, Control-Y interrupt
SUB | 26 | 1a | Substitute
ESC | 27 | 1b | Escape, next character is not echoed
FS | 28 | 1c | File separator
GS | 29 | 1d | Group separator
RS | 30 | 1e | Record separator, block-mode terminator
US | 31 | 1f | Unit separator

Printing Characters (standard characters)

Char | Dec | Hex | Description
 | 32 | 20 | Space
! | 33 | 21 | Exclamation mark
" | 34 | 22 | Quotation mark (&quot; in HTML)
# | 35 | 23 | Cross hatch (number sign)
$ | 36 | 24 | Dollar sign
% | 37 | 25 | Percent sign
& | 38 | 26 | Ampersand
` | 39 | 27 | Closing single quote (apostrophe)
( | 40 | 28 | Opening parentheses
) | 41 | 29 | Closing parentheses
* | 42 | 2a | Asterisk (star, multiply)
+ | 43 | 2b | Plus
, | 44 | 2c | Comma
- | 45 | 2d | Hyphen, dash, minus
. | 46 | 2e | Period
/ | 47 | 2f | Slant (forward slash, divide)
0 | 48 | 30 | Zero
1 | 49 | 31 | One
2 | 50 | 32 | Two
3 | 51 | 33 | Three
4 | 52 | 34 | Four
5 | 53 | 35 | Five
6 | 54 | 36 | Six
7 | 55 | 37 | Seven
8 | 56 | 38 | Eight
9 | 57 | 39 | Nine
: | 58 | 3a | Colon
; | 59 | 3b | Semicolon
< | 60 | 3c | Less than sign
= | 61 | 3d | Equals sign
> | 62 | 3e | Greater than sign
? | 63 | 3f | Question mark
@ | 64 | 40 | At-sign
A | 65 | 41 | Uppercase A
B | 66 | 42 | Uppercase B
C | 67 | 43 | Uppercase C
D | 68 | 44 | Uppercase D
E | 69 | 45 | Uppercase E
F | 70 | 46 | Uppercase F
G | 71 | 47 | Uppercase G
H | 72 | 48 | Uppercase H
I | 73 | 49 | Uppercase I
J | 74 | 4a | Uppercase J
K | 75 | 4b | Uppercase K
L | 76 | 4c | Uppercase L
M | 77 | 4d | Uppercase M
N | 78 | 4e | Uppercase N
O | 79 | 4f | Uppercase O
P | 80 | 50 | Uppercase P
Q | 81 | 51 | Uppercase Q
R | 82 | 52 | Uppercase R
S | 83 | 53 | Uppercase S
T | 84 | 54 | Uppercase T
U | 85 | 55 | Uppercase U
V | 86 | 56 | Uppercase V
W | 87 | 57 | Uppercase W
X | 88 | 58 | Uppercase X
Y | 89 | 59 | Uppercase Y
Z | 90 | 5a | Uppercase Z
[ | 91 | 5b | Opening square bracket
\ | 92 | 5c | Reverse slant (Backslash)
] | 93 | 5d | Closing square bracket
^ | 94 | 5e | Caret (Circumflex)
_ | 95 | 5f | Underscore
` | 96 | 60 | Opening single quote
a | 97 | 61 | Lowercase a
b | 98 | 62 | Lowercase b
c | 99 | 63 | Lowercase c
d | 100 | 64 | Lowercase d
e | 101 | 65 | Lowercase e
f | 102 | 66 | Lowercase f
g | 103 | 67 | Lowercase g
h | 104 | 68 | Lowercase h
i | 105 | 69 | Lowercase i
j | 106 | 6a | Lowercase j
k | 107 | 6b | Lowercase k
l | 108 | 6c | Lowercase l
m | 109 | 6d | Lowercase m
n | 110 | 6e | Lowercase n
o | 111 | 6f | Lowercase o
p | 112 | 70 | Lowercase p
q | 113 | 71 | Lowercase q
r | 114 | 72 | Lowercase r
s | 115 | 73 | Lowercase s
t | 116 | 74 | Lowercase t
u | 117 | 75 | Lowercase u
v | 118 | 76 | Lowercase v
w | 119 | 77 | Lowercase w
x | 120 | 78 | Lowercase x
y | 121 | 79 | Lowercase y
z | 122 | 7a | Lowercase z
{ | 123 | 7b | Opening curly brace
| | 124 | 7c | Vertical line
} | 125 | 7d | Closing curly brace
~ | 126 | 7e | Tilde (approximate)
 | 127 | 7f | Delete (rubout), cross-hatch box

Extended Character Set (ANSI)

Char | Dec | Hex | Description
€ | 128 | 80 |
 | 129 | 81 | Note: does not display in this compiled html help file
‚ | 130 | 82 |
ƒ | 131 | 83 |
„ | 132 | 84 |
… | 133 | 85 |
† | 134 | 86 |
‡ | 135 | 87 |
ˆ | 136 | 88 |
‰ | 137 | 89 |
Š | 138 | 8A |
‹ | 139 | 8B |
Œ | 140 | 8C |
 | 141 | 8D | Note: does not display in this compiled html help file
Ž | 142 | 8E |
 | 143 | 8F | Note: does not display in this compiled html help file
� | 144 | 90 | Note: does not display in this compiled html help file
‘ | 145 | 91 |
’ | 146 | 92 |
“ | 147 | 93 |
” | 148 | 94 |
• | 149 | 95 |
– | 150 | 96 |
— | 151 | 97 |
˜ | 152 | 98 |
™ | 153 | 99 |
š | 154 | 9A |
› | 155 | 9B |
œ | 156 | 9C |
 | 157 | 9D | Note: does not display in this compiled html help file
ž | 158 | 9E |
Ÿ | 159 | 9F |
 | 160 | A0 |
¡ | 161 | A1 |
¢ | 162 | A2 |
£ | 163 | A3 |
¤ | 164 | A4 |
¥ | 165 | A5 |
¦ | 166 | A6 |
§ | 167 | A7 |
¨ | 168 | A8 |
© | 169 | A9 |
ª | 170 | AA |
« | 171 | AB |
¬ | 172 | AC |
 | 173 | AD | Note: may not display in this compiled html help file
® | 174 | AE |
¯ | 175 | AF |
° | 176 | B0 |
± | 177 | B1 |
² | 178 | B2 |
³ | 179 | B3 |
´ | 180 | B4 |
µ | 181 | B5 |
¶ | 182 | B6 |
· | 183 | B7 |
¸ | 184 | B8 |
¹ | 185 | B9 |
º | 186 | BA |
» | 187 | BB |
¼ | 188 | BC |
½ | 189 | BD |
¾ | 190 | BE |
¿ | 191 | BF |
À | 192 | C0 |
Á | 193 | C1 |
Â | 194 | C2 |
Ã | 195 | C3 |
Ä | 196 | C4 |
Å | 197 | C5 |
Æ | 198 | C6 |
Ç | 199 | C7 |
È | 200 | C8 |
É | 201 | C9 |
Ê | 202 | CA |
Ë | 203 | CB |
Ì | 204 | CC |
Í | 205 | CD |
Î | 206 | CE |
Ï | 207 | CF |
Ð | 208 | D0 |
Ñ | 209 | D1 |
Ò | 210 | D2 |
Ó | 211 | D3 |
Ô | 212 | D4 |
Õ | 213 | D5 |
Ö | 214 | D6 |
× | 215 | D7 |
Ø | 216 | D8 |
Ù | 217 | D9 |
Ú | 218 | DA |
Û | 219 | DB |
Ü | 220 | DC |
Ý | 221 | DD |
Þ | 222 | DE |
ß | 223 | DF |
à | 224 | E0 |
á | 225 | E1 |
â | 226 | E2 |
ã | 227 | E3 |
ä | 228 | E4 |
å | 229 | E5 |
æ | 230 | E6 |
ç | 231 | E7 |
è | 232 | E8 |
é | 233 | E9 |
ê | 234 | EA |
ë | 235 | EB |
ì | 236 | EC |
í | 237 | ED |
î | 238 | EE |
ï | 239 | EF |
ð | 240 | F0 |
ñ | 241 | F1 |
ò | 242 | F2 |
ó | 243 | F3 |
ô | 244 | F4 |
õ | 245 | F5 |
ö | 246 | F6 |
÷ | 247 | F7 |
ø | 248 | F8 |
ù | 249 | F9 |
ú | 250 | FA |
û | 251 | FB |
ü | 252 | FC |
ý | 253 | FD |
þ | 254 | FE |
ÿ | 255 | FF |


Clavier : code des touches

Introduction
puce Cette page contient le code de toutes les touches en base décimal, binaire et hexadécimal, mais aussi leur scancode, le bit désarmé du masque et le bit à tester.
Codes des touches

Touche | code décimal | code hexadécimal | code binaire | scancode $007EAB | désarmer bit $600018 | tester bit $60001A
[ON] | #267 | #$010B | #%0000000100001011 | - | - | bit 9
[ENTER] (haut) | #13 | #$000D | #%0000000000001101 | #$37 | bit 6 | bit 6
[ENTER] (bas) | #13 | #$000D | #%0000000000001101 | #$4A | bit 9 | bit 1
[ESPACE] | #32 | #$0020 | #%0000000000100000 | #$21 | bit 4 | bit 0
[MAIN] | - | - | - | #$04 | bit 0 | bit 3
[SHIFT] | - | - | - | #$03 | bit 0 | bit 2
[DIAMAND] | - | - | - | #$02 | bit 0 | bit 1
[2ND] | - | - | - | #$01 | bit 0 | bit 0
[GAUCHE] | #337 | #$0151 | #%0000000101010001 | #$51 | bit 0 | bit 4
[HAUT] | #338 | #$0152 | #%0000000101010010 | #$52 | bit 0 | bit 5
[DROITE] | #340 | #$0154 | #%0000000101010100 | #$54 | bit 0 | bit 6
[BAS] | #344 | #$0158 | #%0000000101011000 | #$58 | bit 0 | bit 7
[EFFACER] | #257 | #$0101 | #%0000000100000001 | #$41 | bit 8 | bit 0
[(] | #40 | #$0028 | #%0000000000101000 | #$26 | bit 4 | bit 5
[)] | #41 | #$0029 | #%0000000000101001 | #$27 | bit 4 | bit 6
[x] | #42 | #$002A | #%0000000000101010 | #$40 | bit 7 | bit 7
[+] | #43 | #$002B | #%0000000000101011 | #$41 | bit 8 | bit 4
[,] | #44 | #$002C | #%0000000000101100 | #$28 | bit 4 | bit 7
[-] | #45 | #$002D | #%0000000000101101 | #$49 | bit 9 | bit 0
[.] | #46 | #$002E | #%0000000000101110 | #$4F | bit 9 | bit 6
[÷] | #47 | #$002F | #%0000000000101111 | #$29 | bit 5 | bit 0
[0] | #48 | #$0030 | #%0000000000110000 | #$4E | bit 9 | bit 5
[1] | #49 | #$0031 | #%0000000000110001 | #$0E | bit 1 | bit 5
[2] | #50 | #$0032 | #%0000000000110010 | #$0F | bit 1 | bit 6
[3] | #51 | #$0033 | #%0000000000110011 | #$10 | bit 1 | bit 7
[4] | #52 | #$0034 | #%0000000000110100 | #$16 | bit 2 | bit 5
[5] | #53 | #$0035 | #%0000000000110101 | #$17 | bit 2 | bit 6
[6] | #54 | #$0036 | #%0000000000110110 | #$18 | bit 2 | bit 7
[7] | #55 | #00$37 | #%0000000000110111 | #$1E | bit 3 | bit 5
[8] | #56 | #$0038 | #%0000000000111000 | #$1F | bit 3 | bit 6
[9] | #57 | #$0039 | #%0000000000111001 | #$20 | bit 3 | bit 7
[=] | #61 | #$003D | #%0000000000111101 | #$3D | bit 7 | bit 4
[A] | #97 | #$0061 | #%0000000001100001 | #$4B | bit 9 | bit 2
[B] | #98 | #$0062 | #%0000000001100010 | #$2A | bit 5 | bit 1
[C] | #99 | #$0063 | #%0000000001100011 | #$1A | bit 3 | bit 1
[D] | #100 | #$0064 | #%0000000001100100 | #$13 | bit 2 | bit 2
[E] | #101 | #$0065 | #%0000000001100101 | #$14 | bit 2 | bit 3
[F] | #102 | #$0066 | #%0000000001100110 | #$1B | bit 3 | bit 2
[G] | #103 | #$0067 | #%0000000001100111 | #$23 | bit 4 | bit 2
[H] | #104 | #$0068 | #%0000000001101000 | #$2B | bit 5 | bit 2
[I] | #105 | #$0069 | #%0000000001101001 | #$3C | bit 7 | bit 3
[J] | #106 | #$006A | #%0000000001101010 | #$33 | bit 6 | bit 2
[K] | #107 | #$006B | #%0000000001101011 | #$3B | bit 7 | bit 2
[L] | #108 | #$006C | #%0000000001101100 | #$43 | bit 8 | bit 2
[M] | #109 | #$006D | #%0000000001101101 | #$3A | bit 7 | bit 1
[N] | #110 | #$006E | #%0000000001101110 | #$32 | bit 6 | bit 1
[O] | #111 | #$006F | #%0000000001101111 | #$44 | bit 8 | bit 3
[P] | #112 | #$0070 | #%0000000001110000 | #$38 | bit 6 | bit 7
[Q] | #113 | #$0071 | #%0000000001110001 | #$4C | bit 9 | bit 3
[R] | #114 | #$0072 | #%0000000001110010 | #$1C | bit 3 | bit 3
[S] | #115 | #$0073 | #%0000000001110011 | #$0B | bit 1 | bit 2
[T] | #116 | #$0074 | #%0000000001110100 | #$24 | bit 4 | bit 3
[U] | #117 | #$0075 | #%0000000001110101 | #$34 | bit 6 | bit 3
[V] | #118 | #$0076 | #%0000000001110110 | #$22 | bit 4 | bit 1
[W] | #119 | #$0077 | #%0000000001110111 | #$0C | bit 1 | bit 3
[X] | #120 | #$0078 | #%0000000001111000 | #$12 | bit 2 | bit 1
[Y] | #121 | #$0079 | #%0000000001111001 | #$2C | bit 5 | bit 3
[Z] | #122 | #$007A | #%0000000001111010 | #$0A | bit 1 | bit 1
[THETA] | #136 | #$0088 | #%0000000010001000 | #$42 | bit 8 | bit 1
[(-)] | #173 | #$00AD | #%0000000010101101 | #$50 | bit 9 | bit 7
[STO] | #258 | #$0102 | #%0000000100000010 | #$19 | bit 3 | bit 0
[SIN] | #259 | #$0103 | #%0000000100000011 | #$2E | bit 5 | bit 5
[COS] | #260 | #$0104 | #%0000000100000100 | #$2F | bit 5 | bit 6
[TAN] | #261 | #$0105 | #%0000000100000101 | #$30 | bit 5 | bit 7
[LN] | #262 | #$0106 | #%0000000100000110 | #$36 | bit 6 | bit 5
[CLEAR] | #263 | #$0107 | #%0000000100000111 | #$3E | bit 7 | bit 5
[ESC] | #264 | #$0108 | #%0000000100001000 | #$47 | bit 8 | bit 6
[APPS] | #265 | #$0109 | #%0000000100001001 | #$3F | bit 7 | bit 6
[MODE] | #266 | #$010A | #%0000000100001010 | #$46 | bit 8 | bit 5
[F1] | #268 | #$010C | #%0000000100001100 | #$35 | bit 6 | bit 4
[F2] | #269 | #$010D | #%0000000100001101 | #$25 | bit 4 | bit 4
[F3] | #270 | #$010E | #%0000000100001110 | #$15 | bit 2 | bit 4
[F4] | #271 | #$010F | #%0000000100001111 | #$4D | bit 9 | bit 4
[F5] | #272 | #$0110 | #%0000000100010000 | #$3D | bit 7 | bit 4
[F6] | #273 | #$0111 | #%0000000100010001 | #$2D | bit 5 | bit 4
[F7] | #274 | #$0112 | #%0000000100010010 | #$1D | bit 3 | bit 4
[F8] | #275 | #$0113 | #%0000000100010011 | #$0D | bit 1 | bit 4

Lisez la section sur les droits d'auteur et la license d'utilisation avant de distribuer Zguide.

Zguide © 1998, Florian DREVET. Tous droits réservés à l'échelle mondiale


Décimal Octal Hex Binaire

table ascii ( 0 - 127 )

       Décimal   Octal   Hex  Binaire   Caractère
       -------   -----   ---  --------    ------
         000      000    00   00000000      NUL    (Null char.)
         001      001    01   00000001      SOH    (Start of Header)
         002      002    02   00000010      STX    (Start of Text)
         003      003    03   00000011      ETX    (End of Text)
         004      004    04   00000100      EOT    (End of Transmission)
         005      005    05   00000101      ENQ    (Enquiry)
         006      006    06   00000110      ACK    (Acknowledgment)
         007      007    07   00000111      BEL    (Bell)
         008      010    08   00001000       BS    (Backspace)
         009      011    09   00001001       HT    (Horizontal Tab)
         010      012    0A   00001010       LF    (Line Feed)
         011      013    0B   00001011       VT    (Vertical Tab)
         012      014    0C   00001100       FF    (Form Feed)
         013      015    0D   00001101       CR    (Carriage Return)
         014      016    0E   00001110       SO    (Shift Out)
         015      017    0F   00001111       SI    (Shift In)
         016      020    10   00010000      DLE    (Data Link Escape)
         017      021    11   00010001      DC1    (XON)(Device Control 1)
         018      022    12   00010010      DC2    (Device Control 2)
         019      023    13   00010011      DC3    (XOFF)(Device Control 3)
         020      024    14   00010100      DC4    (Device Control 4)
         021      025    15   00010101      NAK    (Negative Acknowledgement)
         022      026    16   00010110      SYN    (Synchronous Idle)
         023      027    17   00010111      ETB    (End of Trans. Block)
         024      030    18   00011000      CAN    (Cancel)
         025      031    19   00011001       EM    (End of Medium)
         026      032    1A   00011010      SUB    (Substitute)
         027      033    1B   00011011      ESC    (Escape)
         028      034    1C   00011100       FS    (File Separator)
         029      035    1D   00011101       GS    (Group Separator)
         030      036    1E   00011110       RS    (Request to Send)(Record Separator)
         031      037    1F   00011111       US    (Unit Separator)
         032      040    20   00100000       SP    (Space)
         033      041    21   00100001        !    (exclamation mark)
         034      042    22   00100010        "    (double quote)
         035      043    23   00100011        #    (number sign)
         036      044    24   00100100        $    (dollar sign)
         037      045    25   00100101        %    (percent)
         038      046    26   00100110        &    (ampersand)
         039      047    27   00100111        '    (single quote)
         040      050    28   00101000        (    (left opening parenthesis)
         041      051    29   00101001        )    (right closing parenthesis)
         042      052    2A   00101010        *    (asterisk)
         043      053    2B   00101011        +    (plus)
         044      054    2C   00101100        ,    (comma)
         045      055    2D   00101101        -    (minus or dash)
         046      056    2E   00101110        .    (dot)
         047      057    2F   00101111        /    (forward slash)
         048      060    30   00110000        0
         049      061    31   00110001        1
         050      062    32   00110010        2
         051      063    33   00110011        3
         052      064    34   00110100        4
         053      065    35   00110101        5
         054      066    36   00110110        6
         055      067    37   00110111        7
         056      070    38   00111000        8
         057      071    39   00111001        9
         058      072    3A   00111010        :    (colon)
         059      073    3B   00111011        ;    (semi-colon)
         060      074    3C   00111100        <    (less than sign)
         061      075    3D   00111101        =    (equal sign)
         062      076    3E   00111110        >    (greater than sign)
         063      077    3F   00111111        ?    (question mark)
         064      100    40   01000000        @    (AT symbol)
         065      101    41   01000001        A
         066      102    42   01000010        B
         067      103    43   01000011        C
         068      104    44   01000100        D
         069      105    45   01000101        E
         070      106    46   01000110        F
         071      107    47   01000111        G
         072      110    48   01001000        H
         073      111    49   01001001        I
         074      112    4A   01001010        J
         075      113    4B   01001011        K
         076      114    4C   01001100        L
         077      115    4D   01001101        M
         078      116    4E   01001110        N
         079      117    4F   01001111        O
         080      120    50   01010000        P
         081      121    51   01010001        Q
         082      122    52   01010010        R
         083      123    53   01010011        S
         084      124    54   01010100        T
         085      125    55   01010101        U
         086      126    56   01010110        V
         087      127    57   01010111        W
         088      130    58   01011000        X
         089      131    59   01011001        Y
         090      132    5A   01011010        Z
         091      133    5B   01011011        [    (left opening bracket)
         092      134    5C   01011100        \    (back slash)
         093      135    5D   01011101        ]    (right closing bracket)
         094      136    5E   01011110        ^    (caret cirumflex)
         095      137    5F   01011111        _    (underscore)
         096      140    60   01100000        `
         097      141    61   01100001        a
         098      142    62   01100010        b
         099      143    63   01100011        c
         100      144    64   01100100        d
         101      145    65   01100101        e
         102      146    66   01100110        f
         103      147    67   01100111        g
         104      150    68   01101000        h
         105      151    69   01101001        i
         106      152    6A   01101010        j
         107      153    6B   01101011        k
         108      154    6C   01101100        l
         109      155    6D   01101101        m
         110      156    6E   01101110        n
         111      157    6F   01101111        o
         112      160    70   01110000        p
         113      161    71   01110001        q
         114      162    72   01110010        r
         115      163    73   01110011        s
         116      164    74   01110100        t
         117      165    75   01110101        u
         118      166    76   01110110        v
         119      167    77   01110111        w
         120      170    78   01111000        x
         121      171    79   01111001        y
         122      172    7A   01111010        z
         123      173    7B   01111011        {    (left opening brace)
         124      174    7C   01111100        |    (vertical bar)
         125      175    7D   01111101        }    (right closing brace)
         126      176    7E   01111110        ~    (tilde)
         127      177    7F   01111111      DEL    (delete)


Nouvelle page 3

table ascii étendue ( 128 - 255 )


Jeu de caractères ASCII - ISO 88

Jeu de caractères ASCII - ISO 8859-1 ( Latin - 1 ) - Ouest / Europe de l'ouest

Table de conversion

Hex. | Num. Equivalent | Browser character | Char. Entity Reference | Description
00-1F | 00-31 |  |  |
20 | &#32; |  |  | Space
21 | &#33; | ! |  | Exclamation mark
22 | &#34; | " | &quot; | Double quote
23 | &#35; | # |  | Hash; 'pound sign'
24 | &#36; | $ |  | Dollar sign
25 | &#37; | % |  | Percent sign
26 | &#38; | & | &amp; | Ampersand
27 | &#39; | ' |  | Apostrophe
28 | &#40; | ( |  | Open bracket
29 | &#41; | ) |  | Close bracket
2A | &#42; | * |  | Asterix
2B | &#43; | + |  | Plus sign
2C | &#44; | , |  | Comma
2D | &#45; | - |  | Minus sign
2E | &#46; | . |  | Fullstop; period
2F | &#47; | / |  | Slash; forward slash
30 | &#48; | 0 |  |
31 | &#49; | 1 |  |
32 | &#50; | 2 |  |
33 | &#51; | 3 |  |
34 | &#52; | 4 |  |
35 | &#53; | 5 |  |
36 | &#54; | 6 |  |
37 | &#55; | 7 |  |
38 | &#56; | 8 |  |
39 | &#57; | 9 |  |
3A | &#58; | : |  | Colon
3B | &#59; | ; |  | Semi-colon
3C | &#60; | < | &lt; | Less-than sign
3D | &#61; | = |  | Equals
3E | &#62; | > | &gt; | Greater-than sign
3F | &#63; | ? |  | Question mark
40 | &#64; | @ |  | At sign; commercial at
41 | &#65; | A |  |
42 | &#66; | B |  |
43 | &#67; | C |  |
44 | &#68; | D |  |
45 | &#69; | E |  |
46 | &#70; | F |  |
47 | &#71; | G |  |
48 | &#72; | H |  |
49 | &#73; | I |  |
4A | &#74; | J |  |
4B | &#75; | K |  |
4C | &#76; | L |  |
4D | &#77; | M |  |
4E | &#78; | N |  |
4F | &#79; | O |  |
50 | &#80; | P |  |
51 | &#81; | Q |  |
52 | &#82; | R |  |
53 | &#83; | S |  |
54 | &#84; | T |  |
55 | &#85; | U |  |
56 | &#86; | V |  |
57 | &#87; | W |  |
58 | &#88; | X |  |
59 | &#89; | Y |  |
5A | &#90; | Z |  |
5B | &#91; | [ |  | Open square bracket
5C | &#92; | \ |  | Backslash
5D | &#93; | ] |  | Close square bracket
5E | &#94; | ^ |  | Caret
5F | &#95; | _ |  | Underscore
60 | &#96; | ` |  | Grave accent
61 | &#97; | a |  |
62 | &#98; | b |  |
63 | &#99; | c |  |
64 | &#100; | d |  |
65 | &#101; | e |  |
66 | &#102; | f |  |
67 | &#103; | g |  |
68 | &#104; | h |  |
69 | &#105; | i |  |
6A | &#106; | j |  |
6B | &#107; | k |  |
6C | &#108; | l |  |
6D | &#109; | m |  |
6E | &#110; | n |  |
6F | &#111; | o |  |
70 | &#112; | p |  |
71 | &#113; | q |  |
72 | &#114; | r |  |
73 | &#115; | s |  |
74 | &#116; | t |  |
75 | &#117; | u |  |
76 | &#118; | v |  |
77 | &#119; | w |  |
78 | &#120; | x |  |
79 | &#121; | y |  |
7A | &#122; | z |  |
7B | &#123; | { |  | Left brace; left curly bracket
7C | &#124; | | |  | Vertical bar
7D | &#125; | } |  | Right brace; right curly bracket
7E | &#126; | ~ |  | Tilde
7F-9F | 127-159 |  |  |
A0 | &#160; |  | &nbsp; | Non-breaking space
A1 | &#161; | ¡ | &iexcl; | Inverted exclamation mark
A2 | &#162; | ¢ | &cent; | Cent sign
A3 | &#163; | £ | &pound; | Pound sign
A4 | &#164; | ¤ | &curren; | Currency sign
A5 | &#165; | ¥ | &yen; | Yen sign; yuan sign
A6 | &#166; | ¦ | &brvbar; | Broken bar; broken vertical bar
A7 | &#167; | § | &sect; | Section sign
A8 | &#168; | ¨ | &uml; | Diaeresis; spacing diaeresis
A9 | &#169; | © | &copy; | Copyright sign
AA | &#170; | ª | &ordf; | Feminine ordinal indicator
AB | &#171; | « | &laquo; | Left-pointing double angle quotation mark; left pointing guillemet
AC | &#172; | ¬ | &not; | Not sign
AD | &#173; |  | &shy; | Soft hyphen; discretionary hyphen
AE | &#174; | ® | &reg; | Registered sign; registered trade mark sign
AF | &#175; | ¯ | &macr; | Macron; spacing macron; overline; APL overbar
B0 | &#176; | ° | &deg; | Degree sign
B1 | &#177; | ± | &plusmn; | Plus-minus sign; plus-or-minus sign
B2 | &#178; | ² | &sup2; | Superscript two; superscript digit two; squared
B3 | &#179; | ³ | &sup3; | Superscript three; superscript digit three; cubed
B4 | &#180; | ´ | &acute; | Acute accent; spacing acute
B5 | &#181; | µ | &micro; | Micro sign
B6 | &#182; | ¶ | &para; | Pilcrow sign; paragraph sign
B7 | &#183; | · | &middot; | Middle dot; Georgian comma; Greek middle dot
B8 | &#184; | ¸ | &cedil; | Cedilla; spacing cedilla
B9 | &#185; | ¹ | &sup1; | Superscript one; superscript digit one
BA | &#186; | º | &ordm; | Masculine ordinal indicator
BB | &#187; | » | &raquo; | Right-pointing double angle quotation mark; right pointing guillemet
BC | &#188; | ¼ | &frac14; | Vulgar fraction one quarter; fraction one quarter
BD | &#189; | ½ | &frac12; | Vulgar fraction one half; fraction one half
BE | &#190; | ¾ | &frac34; | Vulgar fraction three quarters; fraction 3 quarters
BF | &#191; | ¿ | &iquest; | Inverted question mark; turned question mark
C0 | &#192; | À | &Agrave; | Latin capital letter A with grave; Latin capital letter A grave
C1 | &#193; | Á | &Aacute; | Latin capital letter A with acute
C2 | &#194; | Â | &Acirc; | Latin capital letter A with circumflex
C3 | &#195; | Ã | &Atilde; | Latin capital letter A with tilde
C4 | &#196; | Ä | &Auml; | Latin capital letter A with diaeresis
C5 | &#197; | Å | &Aring; | Latin capital letter A with ring above; Latin capital letter A ring
C6 | &#198; | Æ | &AElig; | Latin capital letter AE; Latin capital ligature AE
C7 | &#199; | Ç | &Ccedil; | Latin capital letter C with cedilla
C8 | &#200; | È | &Egrave; | Latin capital letter E with grave
C9 | &#201; | É | &Eacute; | Latin capital letter E with acute
CA | &#202; | Ê | &Ecirc; | Latin capital letter E with circumflex
CB | &#203; | Ë | &Euml; | Latin capital letter E with diaeresis
CC | &#204; | Ì | &Igrave; | Latin capital letter I with grave
CD | &#205; | Í | &Iacute; | Latin capital letter I with acute
CE | &#206; | Î | &Icirc; | Latin capital letter I with circumflex
CF | &#207; | Ï | &Iuml; | Latin capital letter I with diaeresis
D0 | &#208; | Ð | &ETH; | Latin capital letter ETH
D1 | &#209; | Ñ | &Ntilde; | Latin capital letter N with tilde
D2 | &#210; | Ò | &Ograve; | Latin capital letter O with grave
D3 | &#211; | Ó | &Oacute; | Latin capital letter O with acute
D4 | &#212; | Ô | &Ocirc; | Latin capital letter O with circumflex
D5 | &#213; | Õ | &Otilde; | Latin capital letter O with tilde
D6 | &#214; | Ö | &Ouml; | Latin capital letter O with diaeresis
D7 | &#215; | × | &times; | Multiplication sign
D8 | &#216; | Ø | &Oslash; | Latin capital letter O with stroke; Latin capital letter O slash
D9 | &#217; | Ù | &Ugrave; | Latin capital letter U with grave
DA | &#218; | Ú | &Uacute; | Latin capital letter U with acute
DB | &#219; | Û | &Ucirc; | Latin capital letter U with circumflex
DC | &#220; | Ü | &Uuml; | Latin capital letter U with diaeresis
DD | &#221; | Ý | &Yacute; | Latin capital letter Y with acute
DE | &#222; | Þ | &THORN; | Latin capital letter THORN
DF | &#223; | ß | &szlig; | Latin small letter sharp s; ess-zed
E0 | &#224; | à | &agrave; | Latin small letter a with grave; Latin small letter a grave
E1 | &#225;/b> | á | &aacute; | Latin small letter a with acute
E2 | &#226; | â | &acirc; | Latin small letter a with circumflex
E3 | &#227; | ã | &atilde; | Latin small letter a with tilde
E4 | &#228; | ä | &auml; | Latin small letter a with diaeresis
E5 | &#229; | å | &aring; | Latin small letter a with ring above; Latin small letter a ring
E6 | &#230; | æ | &aelig; | Latin small letter ae; Latin small ligature ae
E7 | &#231; | ç | &ccedil; | Latin small letter c with cedilla
E8 | &#232; | è | &egrave; | Latin small letter e with grave
E9 | &#233; | é | &eacute; | Latin small letter e with acute
EA | &#234; | ê | &ecirc; | Latin small letter e with circumflex
EB | &#235; | ë | &euml; | Latin small letter e with diaeresis
EC | &#236; | ì | &igrave; | Latin small letter i with grave
ED | &#237; | í | &iacute; | Latin small letter i with acute
EE | &#238; | î | &icirc; | Latin small letter i with circumflex
EF | &#239; | ï | &iuml; | Latin small letter i with diaeresis
F0 | &#240; | ð | &eth; | Latin small letter eth
F1 | &#241; | ñ | &ntilde; | Latin small letter n with tilde
F2 | &#242; | ò | &ograve; | Latin small letter o with grave
F3 | &#243; | ó | &oacute; | Latin small letter o with acute
F4 | &#244; | ô | &ocirc; | Latin small letter o with circumflex
F5 | &#245; | õ | &otilde; | Latin small letter o with tilde
F6 | &#246; | ö | &ouml; | Latin small letter o with diaeresis
F7 | &#247; | ÷ | &divide; | Division sign
F8 | &#248; | ø | &oslash; | Latin small letter o with stroke; Latin small letter o slash
F9 | &#249; | ù | &ugrave; | Latin small letter u with grave
FA | &#250; | ú | &uacute; | Latin small letter u with acute
FB | &#251; | û | &ucirc; | Latin small letter u with circumflex
FC | &#252; | ü | &uuml; | Latin small letter u with diaeresis
FD | &#253; | ý | &yacute; | Latin small letter y with acute
FE | &#254; | þ | &thorn; | Latin small letter thorn
FF | &#255; | ÿ | &yuml; | Latin small letter y with diaeresis


Table Microsoft® Windows Latin-1

Table Microsoft® Windows Latin-1 ( les caractères ajoutés sont en vert )

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

                                     80   &#128;

                                     81   &#129;
low left rising single quote         82   &#130;         &lsquor;   --> &lsquor;
small italic f, function of,   f     83   &#131;         &fnof;     --> ?
   florin
low left rising double quote         84   &#132;         &ldquor;   --> &ldquor;
low horizontal ellipsis              85   &#133;         &hellip;   --> ?
                                                         &ldots;    --> &ldots;
dagger mark                          86   &#134;         &dagger;   --> ?
double dagger mark                   87   &#135;         &Dagger;   --> ?
letter modifying circumflex          88   &#136;         ¹

per thousand (mille) sign            89   &#137;         &permil;   --> ?
capital S caron or hacek             8A   &#138;         &Scaron;   --> ?
left single angle quote mark         8B   &#139;         &lsaquo;   --> ?
   (guillemet)
capital OE ligature                  8C   &#140;         &OElig;    --> ?
                                     8D   &#141;

                                     8E   &#142;
                                     8F   &#143;
                                     90   &#144;
left single quotation mark,          91   &#145;         &lsquo;    --> ?
   high right rising single quote                        &rsquor;   --> &rsquor;
right single quote mark              92   &#146;         &rsquo;    --> ?
left double quotation mark,          93   &#147;         &ldquo;    --> ?
   high right rising double quote                        &rdquor;   --> &rdquor;
right double quote mark              94   &#148;         &rdquo;    --> ?
round filled bullet                  95   &#149;         &bull;     --> ?
en dash                              96   &#150;         &ndash;    --> ?
                                                         &endash;   --> &endash;
em dash                              97   &#151;         &mdash;    --> ?
                                                         &emdash;   --> &emdash;
small spacing tilde accent           98   &#152;         &tilde;¹

trademark sign                       99   &#153;         &trade;    --> ?
small s caron or hacek               9A   &#154;         &scaron;   --> ?
right single angle quote mark        9B   &#155;         &rsaquo;   --> ?
   (guillemet)
small oe ligature                    9C   &#156;         &oelig;    --> ?
                                     9D   &#157;

                                     9E   &#158;
capital Y dieresis or umlaut         9F   &#159;         &Yuml;     --> ?


Table des lettres Bas de casse a

Table des lettres Bas de casse accentuées Latin-1

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

small a grave                  à     E0   &#224; --> à   &agrave;   --> à
small a acute                  á     E1   &#225; --> á   &aacute;   --> á
small a circumflex             â     E2   &#226; --> â   &acirc;    --> â
small a tilde                  ã     E3   &#227; --> ã   &atilde;   --> ã
small a dieresis or umlaut     ä     E4   &#228; --> ä   &auml;     --> ä
small a ring                   å     E5   &#229; --> å   &aring;    --> å
small ae ligature              æ     E6   &#230; --> æ   &aelig;    --> æ
small c cedilla                ç     E7   &#231; --> ç   &ccedil;   --> ç
small e grave                  è     E8   &#232; --> è   &egrave;   --> è
small e acute                  é     E9   &#233; --> é   &eacute;   --> é
small e circumflex             ê     EA   &#234; --> ê   &ecirc;    --> ê
small e dieresis or umlaut     ë     EB   &#235; --> ë   &euml;     --> ë
small i grave                  ì     EC   &#236; --> ì   &igrave;   --> ì
small i acute                  í     ED   &#237; --> í   &iacute;   --> í
small i circumflex             î     EE   &#238; --> î   &icirc;    --> î
small i dieresis or umlaut     ï     EF   &#239; --> ï   &iuml;     --> ï

small eth                      ð     F0   &#240; --> ð   &eth;      --> ð
small n tilde                  ñ     F1   &#241; --> ñ   &ntilde;   --> ñ
small o grave                  ò     F2   &#242; --> ò   &ograve;   --> ò
small o acute                  ó     F3   &#243; --> ó   &oacute;   --> ó
small o circumflex             ô     F4   &#244; --> ô   &ocirc;    --> ô
small o tilde                  õ     F5   &#245; --> õ   &otilde;   --> õ
small o dieresis or umlaut     ö     F6   &#246; --> ö   &ouml;     --> ö
division sign                  ÷     F7   &#247; --> ÷   &divide;   --> ÷
small o slash                  ø     F8   &#248; --> ø   &oslash;   --> ø
small u grave                  ù     F9   &#249; --> ù   &ugrave;   --> ù
small u acute                  ú     FA   &#250; --> ú   &uacute;   --> ú
small u circumflex             û     FB   &#251; --> û   &ucirc;    --> û
small u dieresis or umlaut     ü     FC   &#252; --> ü   &uuml;     --> ü
small y acute                  ý     FD   &#253; --> ý   &yacute;   --> ý
small thorn                    þ     FE   &#254; --> þ   &thorn;    --> þ
small y dieresis or umlaut     ÿ     FF   &#255; --> ÿ   &yuml;     --> ÿ


Table des Lettres capitales acce

Table des Lettres capitales accentuées Latin-1

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

capital A grave                À     C0   &#192; --> À   &Agrave;   --> À
capital A acute                Á     C1   &#193; --> Á   &Aacute;   --> Á
capital A circumflex           Â     C2   &#194; --> Â   &Acirc;    --> Â
capital A tilde                Ã     C3   &#195; --> Ã   &Atilde;   --> Ã
capital A dieresis or umlaut   Ä     C4   &#196; --> Ä   &Auml;     --> Ä
capital A ring                 Å     C5   &#197; --> Å   &Aring;    --> Å
capital AE ligature            Æ     C6   &#198; --> Æ   &AElig;    --> Æ
capital C cedilla              Ç     C7   &#199; --> Ç   &Ccedil;   --> Ç
capital E grave                È     C8   &#200; --> È   &Egrave;   --> È
capital E acute                É     C9   &#201; --> É   &Eacute;   --> É
capital E circumflex           Ê     CA   &#202; --> Ê   &Ecirc;    --> Ê
capital E dieresis or umlaut   Ë     CB   &#203; --> Ë   &Euml;     --> Ë
capital I grave                Ì     CC   &#204; --> Ì   &Igrave;   --> Ì
capital I acute                Í     CD   &#205; --> Í   &Iacute;   --> Í
capital I circumflex           Î     CE   &#206; --> Î   &Icirc;    --> Î
capital I dieresis or umlaut   Ï     CF   &#207; --> Ï   &Iuml;     --> Ï
capital ETH                    Ð     D0   &#208; --> Ð   &ETH;      --> Ð
capital N tilde                Ñ     D1   &#209; --> Ñ   &Ntilde;   --> Ñ
capital O grave                Ò     D2   &#210; --> Ò   &Ograve;   --> Ò
capital O acute                Ó     D3   &#211; --> Ó   &Oacute;   --> Ó
capital O circumflex           Ô     D4   &#212; --> Ô   &Ocirc;    --> Ô
capital O tilde                Õ     D5   &#213; --> Õ   &Otilde;   --> Õ
capital O dieresis or umlaut   Ö     D6   &#214; --> Ö   &Ouml;     --> Ö
multiplication sign            ×     D7   &#215; --> ×   &times;    --> ×
capital O slash                Ø     D8   &#216; --> Ø   &Oslash;   --> Ø
capital U grave                Ù     D9   &#217; --> Ù   &Ugrave;   --> Ù
capital U acute                Ú     DA   &#218; --> Ú   &Uacute;   --> Ú
capital U circumflex           Û     DB   &#219; --> Û   &Ucirc;    --> Û
capital U dieresis or umlaut   Ü     DC   &#220; --> Ü   &Uuml;     --> Ü
capital Y acute                Ý     DD   &#221; --> Ý   &Yacute;   --> Ý
capital THORN                  Þ     DE   &#222; --> Þ   &THORN;    --> Þ
small sharp s, sz ligature     ß     DF   &#223; --> ß   &szlig;    --> ß


table ascii - ISO 8859-1 (Latin-1) Entités

Table des Caractères spéciaux

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

non-breaking space                   A0   &#160; -->     &nbsp;     -->
inverted exclamation mark      ¡     A1   &#161; --> ¡   &iexcl;    --> ¡
cent sign                      ¢     A2   &#162; --> ¢   &cent;     --> ¢
pound sterling sign            £     A3   &#163; --> £   &pound;    --> £
general currency sign          ¤     A4   &#164; --> ¤   &curren;   --> ¤
yen sign                       ¥     A5   &#165; --> ¥   &yen;      --> ¥
broken vertical bar            ¦     A6   &#166; --> ¦   &brvbar;   --> ¦
                                                         &brkbar;   --> &brkbar;
section sign                   §     A7   &#167; --> §   &sect;     --> §
spacing dieresis or umlaut     ¨     A8   &#168; --> ¨   &uml;      --> ¨
                                                         &die;      --> &die;
copyright sign                 ©     A9   &#169; --> ©   &copy;     --> ©
feminine ordinal indicator     ª     AA   &#170; --> ª   &ordf;     --> ª
left (double) angle quote      «     AB   &#171; --> «   &laquo;    --> «

   (guillemet)
logical not sign               ¬     AC   &#172; --> ¬   &not;      --> ¬
soft hyphen                         AD   &#173; -->    &shy;      -->
registered trademark sign      ®     AE   &#174; --> ®   &reg;      --> ®
spacing macron (long) accent,  ¯     AF   &#175; --> ¯   &macr;     --> ¯
                                                         &hibar;    --> &hibar;
degree sign                    °     B0   &#176; --> °   &deg;      --> °
plus-or-minus sign             ±     B1   &#177; --> ±   &plusmn;   --> ±
superscript 2                  ²     B2   &#178; --> ²   &sup2;     --> ²
superscript 3                  ³     B3   &#179; --> ³   &sup3;     --> ³
spacing acute accent           ´     B4   &#180; --> ´   &acute;    --> ´
micro sign                     µ     B5   &#181; --> µ   &micro;    --> µ
paragraph sign, pilcrow sign   ¶     B6   &#182; --> ¶   &para;     --> ¶
middle dot, centered dot       ·     B7   &#183; --> ·   &middot;   --> ·
spacing cedilla                ¸     B8   &#184; --> ¸   &cedil;    --> ¸
superscript 1                  ¹     B9   &#185; --> ¹   &sup1;     --> ¹
masculine ordinal indicator    º     BA   &#186; --> º   &ordm;     --> º
right (double) angle quote     »     BB   &#187; --> »   &raquo;    --> »
   (guillemet)
fraction 1/4                   ¼     BC   &#188; --> ¼   &frac14;   --> ¼
fraction 1/2                   ½     BD   &#189; --> ½   &frac12;   --> ½
                                                         &half;     --> &half;
fraction 3/4                   ¾     BE   &#190; --> ¾   &frac34;   --> ¾
inverted question mark         ¿     BF   &#191; --> ¿   &iquest;   --> ¿


table ascii - US avec correspondances clavier

Caractères de contrôle

Description                    Char  Hex  Character
                                          Référence
                                          (Dec)

null                   NUL     ^@    00   &#000;
start of heading       SOH     ^A    01   &#001;
start of text          STX     ^B    02   &#002;
end of text            ETX     ^C    03   &#003;

end of transmission    EOT     ^D    04   &#004;
enquiry                ENQ     ^E    05   &#005;
acknowledge            ACK     ^F    06   &#006;
bell                   BEL     ^G    07   &#007;

backspace              BS      ^H    08   &#008;
horizontal tab         HT      ^I    09   &#009;
line feed, new line    LF, NL  ^J    0A   &#010;
vertical tab           VT      ^K    0B   &#011;
form feed, new page    FF, NP  ^L    0C   &#012;

carriage return        CR      ^M    0D   &#013;
shift out              SO      ^N    0E   &#014;
shift in               SI      ^O    0F   &#015;
data link escape       DLE     ^P    10   &#016;

device control 1       DC1     ^Q    11   &#017;
device control 2       DC2     ^R    12   &#018;
device control 3       DC3     ^S    13   &#019;
device control 4       DC4     ^T    14   &#020;

negative acknowledge   NAK     ^U    15   &#021;
synchronous idle       SYN     ^V    16   &#022;
end of trans. block    ETB     ^W    17   &#023;
cancel                 CAN     ^X    18   &#024;

end of medium          EM      ^Y    19   &#025;
substitute             SUB     ^Z    1A   &#026;
escape                 ESC     ^[    1B   &#027;
file separator         FS      ^\    1C   &#028;

group separator        GS      ^]    1D   &#029;
record separator       RS      ^^    1E   &#030;
unit separator         US      ^_    1F   &#031;


Description C

table ascii des Caractères spéciaux et nombres

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

space                                20   &#032; -->     &sp;       --> &sp;
exclamation mark               !     21   &#033; --> !   &excl;     --> &excl;
(double) quotation mark        "     22   &#034; --> "   &quot;     --> "

number sign                    #     23   &#035; --> #   &num;      --> &num;
dollar sign                    $     24   &#036; --> $   &dollar;   --> &dollar;
percent sign                   %     25   &#037; --> %   &percnt;   --> &percnt;
ampersand                      &     26   &#038; --> &   &amp;      --> &

apostrophe,                    '     27   &#039; --> '   &apos;     --> &apos;
   single quote mark
left parenthesis               (     28   &#040; --> (   &lpar;     --> &lpar;
right parenthesis              )     29   &#041; --> )   &rpar;     --> &rpar;
asterisk                       *     2A   &#042; --> *   &ast;      --> &ast;
plus sign                      +     2B   &#043; --> +   &plus;     --> &plus;
comma                          ,     2C   &#044; --> ,   &comma;    --> &comma;
minus sign, hyphen             -     2D   &#045; --> -   &hyphen;   --> &hyphen;
                                                         &minus;    --> −

period, decimal point,         .     2E   &#046; --> .   &period;   --> &period;
   full stop
slash, virgule, solidus        /     2F   &#047; --> /   &sol;      --> &sol;
digit 0                        0     30   &#048; --> 0
digit 1                        1     31   &#049; --> 1
digit 2                        2     32   &#050; --> 2
digit 3                        3     33   &#051; --> 3
digit 4                        4     34   &#052; --> 4
digit 5                        5     35   &#053; --> 5
digit 6                        6     36   &#054; --> 6
digit 7                        7     37   &#055; --> 7
digit 8                        8     38   &#056; --> 8
digit 9                        9     39   &#057; --> 9
colon                          :     3A   &#058; --> :   &colon;    --> &colon;
semicolon                      ;     3B   &#059; --> ;   &semi;     --> &semi;
less-than sign                 <     3C   &#060; --> <   &lt;       --> <

equal sign                     =     3D   &#061; --> =   &equals;   --> &equals;
greater-than sign              >     3E   &#062; --> >   &gt;       --> >
question mark                  ?     3F   &#063; --> ?   &quest;    --> &quest;


Description C

table ascii des lettres Bas de casse

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

spacing grave accent,          `     60   &#096; --> `   &grave;    --> &grave;
   back apostrophe
small a                        a     61   &#097; --> a
small b                        b     62   &#098; --> b
small c                        c     63   &#099; --> c
small d                        d     64   &#100; --> d
small e                        e     65   &#101; --> e
small f                        f     66   &#102; --> f
small g                        g     67   &#103; --> g
small h                        h     68   &#104; --> h
small i                        i     69   &#105; --> i
small j                        j     6A   &#106; --> j
small k                        k     6B   &#107; --> k
small l                        l     6C   &#108; --> l
small m                        m     6D   &#109; --> m
small n                        n     6E   &#110; --> n
small o                        o     6F   &#111; --> o
small p                        p     70   &#112; --> p
small q                        q     71   &#113; --> q
small r                        r     72   &#114; --> r
small s                        s     73   &#115; --> s
small t                        t     74   &#116; --> t
small u                        u     75   &#117; --> u
small v                        v     76   &#118; --> v
small w                        w     77   &#119; --> w
small x                        x     78   &#120; --> x
small y                        y     79   &#121; --> y
small z                        z     7A   &#122; --> z
left brace (curly bracket)     {     7B   &#123; --> {   &lcub;     --> &lcub;
vertical bar                   |     7C   &#124; --> |   &verbar;   --> &verbar;
right brace (curly bracket)    }     7D   &#125; --> }   &rcub;     --> &rcub;
tilde accent                   ~     7E   &#126; --> ~   &tilde;    --> ?

delete                 DEL     ^?    7F   &#127;


Description C

table ascii des Lettres capitales

Description                    Char  Hex  Character      Entity
                                          Reference      Name
                                          (Dec)

commercial at sign             @     40   &#064; --> @   &commat;   --> &commat;
capital A                      A     41   &#065; --> A
capital B                      B     42   &#066; --> B
capital C                      C     43   &#067; --> C
capital D                      D     44   &#068; --> D
capital E                      E     45   &#069; --> E
capital F                      F     46   &#070; --> F
capital G                      G     47   &#071; --> G
capital H                      H     48   &#072; --> H
capital I                      I     49   &#073; --> I
capital J                      J     4A   &#074; --> J
capital K                      K     4B   &#075; --> K
capital L                      L     4C   &#076; --> L
capital M                      M     4D   &#077; --> M
capital N                      N     4E   &#078; --> N
capital O                      O     4F   &#079; --> O
capital P                      P     50   &#080; --> P
capital Q                      Q     51   &#081; --> Q
capital R                      R     52   &#082; --> R
capital S                      S     53   &#083; --> S
capital T                      T     54   &#084; --> T
capital U                      U     55   &#085; --> U
capital V                      V     56   &#086; --> V
capital W                      W     57   &#087; --> W
capital X                      X     58   &#088; --> X
capital Y                      Y     59   &#089; --> Y
capital Z                      Z     5A   &#090; --> Z
left square bracket            [     5B   &#091; --> [   &lsqb;     --> &lsqb;
backslash, reverse solidus     \     5C   &#092; --> \   &bsol;     --> &bsol;
right square bracket           ]     5D   &#093; --> ]   &rsqb;     --> &rsqb;
spacing circumflex accent      ^     5E   &#094; --> ^   &circ;     --> ?
spacing underscore, low line,  _     5F   &#095; --> _   &lowbar;   --> &lowbar;
   horizontal bar                                        &horbar;   --> &horbar;


Table de conversion

Table de conversion : Décimal - Hexa-décimal - Octal - Binaire

Dec
Hex
Oct
Binaire
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

         0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F

         000
001
002
003
004
005
006
007
010
011
012
013
014
015
016
017

         00000000
00000001
00000010
00000011
00000100
00000101
00000110
00000111
00001000
00001001
00001010
00001011
00001100
00001101
00001110
00001111

Dec
Hex
Oct
Binaire
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

         10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F

         020
021
022
023
024
025
026
027
030
031
032
033
034
035
036
037

         00010000
00010001
00010010
00010011
00010100
00010101
00010110
00010111
00011000
00011001
00011010
00011011
00011100
00011101
00011110
00011111

Dec
Hex
Oct
Binaire
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

         20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F

         040
041
042
043
044
045
046
047
050
051
052
053
054
055
056
057

         00100000
00100001
00100010
00100011
00100100
00100101
00100110
00100111
00101000
00101001
00101010
00101011
00101100
00101101
00101110
00101111

Dec
Hex
Oct
Binaire
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

         30
31
32
33
34
35
36
37
38
39
3A
3B
3C
3D
3E
3F

         060
061
062
063
064
065
066
067
070
071
072
073
074
075
076
077

         00110000
00110001
00110010
00110011
00110100
00110101
00110110
00110111
00111000
00111001
00111010
00111011
00111100
00111101
00111110
00111111

Dec
Hex
Oct
Binaire
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

         40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F

         100
101
102
103
104
105
106
107
110
111
112
113
114
115
116
117

         01000000
01000001
01000010
01000011
01000100
01000101
01000110
01000111
01001000
01001001
01001010
01001011
01001100
01001101
01001110
01001111

Dec
Hex
Oct
Binaire
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

         50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F

         120
121
122
123
124
125
126
127
130
131
132
133
134
135
136
137

         01010000
01010001
01010010
01010011
01010100
01010101
01010110
01010111
01011000
01011001
01011010
01011011
01011100
01011101
01011110
01011111

Dec
Hex
Oct
Binaire
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

         60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F

         140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157

         01100000
01100001
01100010
01100011
01100100
01100101
01100110
01100111
01101000
01101001
01101010
01101011
01101100
01101101
01101110
01101111

Dec
Hex
Oct
Binaire
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

         70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F

         160
161
162
163
164
165
166
167
170
171
172
173
174
175
176
177

         01110000
01110001
01110010
01110011
01110100
01110101
01110110
01110111
01111000
01111001
01111010
01111011
01111100
01111101
01111110
01111111

Dec
Hex
Oct
Binaire
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

         80
81
82
83
84
85
86
87
88
89
8A
8B
8C
8D
8E
8F

         200
201
202
203
204
205
206
207
210
211
212
213
214
215
216
217

         10000000
10000001
10000010
10000011
10000100
10000101
10000110
10000111
10001000
10001001
10001010
10001011
10001100
10001101
10001110
10001111

Dec
Hex
Oct
Binaire
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

         90
91
92
93
94
95
96
97
98
99
9A
9B
9C
9D
9E
9F

         220
221
222
223
224
225
226
227
230
231
232
233
234
235
236
237

         10010000
10010001
10010010
10010011
10010100
10010101
10010110
10010111
10011000
10011001
10011010
10011011
10011100
10011101
10011110
10011111

Dec
Hex
Oct
Binaire
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

         A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF

         240
241
242
243
244
245
246
247
250
251
252
253
254
255
256
257

         10100000
10100001
10100010
10100011
10100100
10100101
10100110
10100111
10101000
10101001
10101010
10101011
10101100
10101101
10101110
10101111

Dec
Hex
Oct
Binaire
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

         B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF

         260
261
262
263
264
265
266
267
270
271
272
273
274
275
276
277

         10110000
10110001
10110010
10110011
10110100
10110101
10110110
10110111
10111000
10111001
10111010
10111011
10111100
10111101
10111110
10111111

Dec
Hex
Oct
Binaire
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

         C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF

         300
301
302
303
304
305
306
307
310
311
312
313
314
315
316
317

         11000000
11000001
11000010
11000011
11000100
11000101
11000110
11000111
11001000
11001001
11001010
11001011
11001100
11001101
11001110
11001111

Dec
Hex
Oct
Binaire
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

         D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DD
DE
DF

         320
321
322
323
324
325
326
327
330
331
332
333
334
335
336
337

         11010000
11010001
11010010
11010011
11010100
11010101
11010110
11010111
11011000
11011001
11011010
11011011
11011100
11011101
11011110
11011111

Dec
Hex
Oct
Binaire
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239

         E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EE
EF

         340
341
342
343
344
345
346
347
350
351
352
353
354
355
356
357

         11100000
11100001
11100010
11100011
11100100
11100101
11100110
11100111
11101000
11101001
11101010
11101011
11101100
11101101
11101110
11101111

Dec
Hex
Oct
Binaire
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255

         F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
FF

         360
361
362
363
364
365
366
367
370
371
372
373
374
375
376
377

         11110000
11110001
11110010
11110011
11110100
11110101
11110110
11110111
11111000
11111001
11111010
11111011
11111100
11111101
11111110
11111111


Table des Caractères spéciaux

Description                    Char  Hex                 Entity Name

for all                              22                  &forall;   --> ∀
there exists                         24                  &exist;    --> ∃
backward epsilon, such that          27                  &bepsi;    --> &bepsi;
low asterisk math operator           2A                     --> ∗

Table des lettres capitales - Alphabet Grec

Description                    Char  Hex                 Entity Name
congruent                            40                  &cong;     --> ≅
capital Alpha²                 A     41                  &Agr;      --> &Agr;
                                                         &Alpha;    --> Α

capital Beta²                  B     42                  &B&lowast;gr;--> &Bgr;
                                                         &Beta;     --> Β
capital Chi                    X     43                  &KHgr;     --> &KHgr;
                                                         &Chi;      --> Χ

capital Delta                        44                  &Delta;    --> Δ
capital Epsilon²               E     45                  &Egr;      --> &Egr;
                                                         &Epsilon;  --> Ε

                                                         &Epsi;     --> &Epsi;
capital Phi                          46                  &PHgr;     --> &PHgr;
                                                         &Phi;      --> Φ
capital Gamma                        47                  &Gamma;    --> Γ

capital Eta²                   H     48                  &EEgr;     --> &EEgr;
                                                         &Eta;      --> Η
capital Iota²                  I     49                  &Igr;      --> &Igr;
                                                         &Iota;     --> Ι

small script theta,                  4A                  &thetav;   --> &thetav;
   curly theta                                           &vtheta;   --> &vtheta;
capital Kappa²                 K     4B                  &Kgr;      --> &Kgr;
                                                         &Kappa;    --> Κ

capital Lambda                       4C                  &Lambda;   --> Λ
capital Mu²                    M     4D                  &Mgr;      --> &Mgr;
                                                         &Mu;       --> Μ

capital Nu²                    N     4E                  &Ngr;      --> &Ngr;
                                                         &Nu;       --> Ν
capital Omicron²               O     4F                  &Ogr;      --> &Ogr;
                                                         &Omicron;  --> Ο

capital Pi                           50                  &Pi;       --> Π
capital Theta                        51                  &Theta;    --> Θ
capital Rho                    P     52                  &Rgr;      --> &Rgr;
                                                         &Rho;      --> Ρ

capital Sigma                        53                  &Sigma;    --> Σ
capital Tau²                   T     54                  &Tgr;      --> &Tgr;
                                                         &Tau;      --> Τ

capital Upsilon                Y     55                  &Upsi;     --> &Upsi;
                                                         &Upsilon;  --> Υ
small final sigma                    56                  &sfgr;     --> &sfgr;
                                                         &sigmav;   --> &sigmav;
                                                         &vsigma;   --> &vsigma;
capital Omega, ohm sign              57                  &Omega;    --> Ω

                                                         &ohm;      --> &ohm;
capital Xi                           58                  &Xi;       --> Ξ
capital Psi                          59                  &Psi;      --> Ψ
capital Zeta²                  Z     5A                  &Zgr;      --> &Zgr;
                                                         &Zeta;     --> Ζ

therefore, hence                     5C                  &there4;   --> ∴

perpendicular                        5E                  &perp;     --> ⊥

Table des lettres Bas de casse Alphabet Grec

Description                    Char  Hex                 Entity
                                                         Name

radical extension,                   60                  ¹
   spacing overscore
small alpha                          61                  &alpha;    --> α

small beta                           62                  &beta;     --> β
small chi                            63                  &chi;      --> χ
small delta                          64                  &delta;    --> δ

small script epsilon,                65                  &vepsilon; --> &vepsilon;
   curly epsilon
small (straight) phi                 66                  &phis;     --> &phis;
                                                         &phi;      --> φ

small gamma                          67                  &gamma;    --> γ
small eta                            68                  &eta;      --> η
small iota                           69                  &iota;     --> ι

small script phi, curly phi          6A                  &phiv;     --> &phiv;
                                                         &varphi;   --> &varphi;
small kappa                          6B                  &kappa;    --> κ
small lambda                         6C                  &lambda;   --> λ

small mu                       µ     6D                         --> μ
small nu                             6E                  &nu;       --> ν
small omicron²                 o     6F                  &ogr;      --> &ogr;
                                                         &omicron;  --> ο

small pi                             70                  &pi;       --> π
small (straight) theta               71                  &thetas;   --> &thetas;
                                                         &theta;    --> θ

small rho                            72                  &rho;      --> ρ
small sigma                          73                  &sigma;    --> σ
small tau                            74                  &tau;      --> τ

small upsilon                        75                  &upsi;     --> &upsi;
                                                         &upsilon;  --> υ
small omega pi, curly pi             76                  &piv;      --> ϖ

                                                         &var&mu;pi;--> &varpi;
small omega                          77                  &omega;    --> ω
small xi                             78                  &xi;       --> ξ

small psi                            79                  &psi;      --> ψ
small zeta                           7A                  &zeta;     --> ζ
similar sign, tilde operator         7E                  &sim;      --> ∼

Table des Caractères spéciaux

Description                    Char  Hex                 Entity
                                                         Name

capital Upsilon hook                 A1                  ¹
prime, minute mark                   A2                  &prime;    --> ′

less-than-or-equal sign              A3                  &le;       --> ≤
fraction slash                       A4                  ¹
infinity                             A5                  &infin;    --> ∞

                                                         &inf;      --> &inf;
small italic f,function of,florin    A6                  &fnof;     --> ?
club suit symbol                     A7                  &clubs;    --> ♣

diamond suit symbol                  A8                  &diams;    --> ♦
heart suit symbol                    A9                  &hearts;   --> ♥
spade suit symbol                    AA                  &spades;   --> ♠

horizontal (left-right) arrow        AB                  &harr;     --> ↔
left arrow                           AC                  &larr;     --> ←
up arrow                             AD                  &uarr;     --> ↑

right arrow                          AE                  &rarr;     --> →
down arrow                           AF                  &darr;     --> ↓

double prime, second mark            B2                  &Prime;    --> ″

greater-than-or-equal sign           B3                  &ge;       --> ≥

proportional to                      B5                  &prop;     --> ∝
partial differential, curly d        B6                  &part;     --> ∂

                                                         &pd;       --> &pd;
round filled bullet                  B7                  &bull;     --> ?

not-equal sign                       B9                  &ne;       --> ≠
identical to, equivalent             BA                  &equiv;    --> ≡

approximately equal                  BB                  &ape;      --> &ape;
                                                         &ap;       --> &ap;
low horizontal ellipsis              BC                  &hellip;   --> ?
                                                         &ldots;    --> &ldots;
vertical arrow extension             BD                  ¹

horizontal arrow extension           BE                  ¹
down and left arrow,                 BF                  ¹
   carriage return arrow

Table des Caractères spéciaux ISO 8879 (Adobe Symbol Font) Entités

Description                    Char  Hex                 Entity
                                                         Name

aleph, first transfinite cardinal    C0                  &aleph;    --> &aleph;
black-letter I,imaginary part of     C1                  &image;    --> ℑ

black-letter R,real part of          C2                  &real;     --> ℜ
Weierstrassian function p            C3                  &weierp;   --> ℘
circled multiplication sign          C4                  &otimes;   --> ⊗

circled plus sign                    C5                  &oplus;    --> ⊕
empty set                            C6                  &empty;    --> ∅
set intersection                     C7                  &cap;      --> ∩

set union                            C8                  &cup;      --> ∪
proper superset of                   C9                  &sup;      --> ⊃
superset-of-or-equal-to              CA                  &supe;     --> ⊇

not a subset of                      CB                  &nsub;     --> ⊄
proper subset of                     CC                  &sub;      --> ⊂
subset-of-or-equal-to                CD                  &sube;     --> ⊆

element of, set membership           CE                  &isin;     --> ∈
not an element of                    CF                  &notin;    --> ∉
angle                                D0                  &ang;      --> ∠

del operator, gradient, nabla        D1                  &nabla;    --> ∇
trademark sign                       D4                  &trade;    --> ?
n-ary product operator               D5                  &prod;     --> ∏

radical, square root                 D6                  &radic;    --> √
small middle dot,math dot operator   D7                  &sdot;     --> ⋅
logical and                          D9                  &and;      --> ∧

logical or                           DA                  &or;       --> ∨
horizontal double arrow              DB                  &hArr;     --> ⇔
left double arrow                    DC                  &lArr;     --> ⇐

up double arrow                      DD                  &uArr;     --> ⇑
right double arrow                   DE                  &rArr;     --> ⇒
down double arrow                    DF                  &dArr;     --> ⇓

Table des Caractères spéciaux

Description                    Char  Hex                 Entity
                                                         Name

lozenge, total mark                  E0                  &loz;      --> ◊

left angle bracket                   E1                  &lang;     --> 〈

n-ary summation operator             E5                  &sum;      --> ∑
left parenthesis top                 E6                  ¹

left parenthesis extension           E7                  ¹
left parenthesis bottom              E8                  ¹
left bracket top (ceiling)           E9                  &lceil;    --> ⌈

left bracket extension               EA                  ¹
left bracket bottom (floor)          EB                  &lfloor;   --> ⌊
left brace top                       EC                  ¹

left brace middle                    ED                  ¹
left brace bottom                    EE                  ¹
brace extension                      EF                  ¹

right angle bracket                  F1                  &rang;     --> 〉

integral sign                        F2                  &int;      --> ∫
integral top                         F3                  ¹
integral extension                   F4                  ¹
integral bottom                      F5                  ¹

right parenthesis top                F6                  ¹
right parenthesis extension          F7                  ¹
right parenthesis bottom             F8                  ¹
right bracket top (ceiling)          F9                  &rceil;    --> ⌉

right bracket extension              FA                  ¹
right bracket bottom (floor)         FB                  &rfloor;   --> ⌋
right brace top                      FC                  ¹

right brace middle                   FD                  ¹
right brace bottom                   FE                  ¹


Table des Entités HTML

Description                    Char                      Entity
                                                         Name

spacing breve (short) accent                             &breve;    --> &breve;
spacing caron accent                                     &caron;    --> &caron;
centered horizontal ellipsis                             &cdots;    --> &cdots;
double acute accent                                      &dblac;    --> &dblac;
diagonal ellipsis                                        &dellip;   --> &dellip;
                                                         &ddots;    --> &ddots;
spacing dot above accent                                 &dot;      --> &dot;
array column fill ellipsis                               &dotfill;  --> &dotfill;
small script l                                           &ell;      --> &ell;
em space (the width of an "m")                           &emsp;     -->

en space (1/2 em space)                                  &ensp;     -->
small (straight) epsilon                                 &epsi;     --> &epsi;
                                                         &epsilon;  --> ε
fraction 1/8                                             &frac18;   --> &frac18;
fraction 3/8                                             &frac38;   --> &frac38;
fraction 5/8                                             &frac58;   --> &frac58;
fraction 7/8                                             &frac78;   --> &frac78;
hair width space                                         &hairsp;   --> &hairsp;
if and only if (iff)                                     &iff;      --> &iff;
left determinant vertical bar                            &ldet;     --> &ldet;
contains as a member                                     &ni;       --> ∋

spacing ogonek accent                                    &ogon;     --> &ogon;
Planck's constant h over 2 pi,                           &planck;   --> &planck;
   small italic h slash (bar)
quad em space                                            &quad;     --> &quad;
right determinant vertical bar                           &rdet;     --> &rdet;
spacing ring above accent                                &ring;     --> &ring;
soft break space                                         &sbsp;     --> &sbsp;
since, because                                           &becaus;   --> &becaus;
(inverted therefore) sung text sign, music note          &sung;     --> &sung;
thin space (1/6 em space)                                &thinsp;   -->

small rho variant                                        &varrho; --> &varrho;
vertical ellipsis                                        &vellip;   --> &vellip;
vertical elipsis also                                    &vdots;    --> &vdots;


Table des Fonctions mathématique

Table des Fonctions mathématiques

Description                    String                    Entity
                                                         Name

logarithmic function           log                       &log;      --> &log;
sine function                  sin                       &sin;      --> &sin;
hyperbolic tangent function    tanh                      &tanh;     --> &tanh;
  etc.


Table des Couleurs

Table des Couleurs : Safe (html) : Table hexadécimale

#FFFFFF

# FFFFCC

# FFFF99

# FFFF66

# FFFF33

# FFFF00

# FFCCFF

# FFCCCC

# FFCC99

# FFCC66

# FFCC33

# FFCC00

# FF99FF

# FF99CC

# FF9999

# FF9966

# FF9933

# FF9900

# FF66FF

# FF66CC

# FF6699

# FF6666

# FF6633

# FF6600

# FF33FF

# FF33CC

# FF3399

# FF3366

# FF3333

# FF3300

# FF00FF

# FF00CC

# FF0099

# FF0066

# FF0033

# FF0000

# CCFFFF

# CCFFCC

# CCFF99

# CCFF66

# CCFF33

# CCFF00

# CCCCFF

# CCCCCC

# CCCC99

# CCCC66

# CCCC33

# CCCC00

# CC99FF

# CC99CC

# CC9999

# CC9966

# CC9933

# CC9900

# CC66FF

# CC66CC

# CC6699

# CC6666

# CC6633

# CC6600

# CC33FF

# CC33CC

# CC3399

# CC3366

# CC3333

# CC3300

# CC00FF

# CC00CC

# CC0099

# CC0066

# CC0033

# CC0000

# 99FFFF

# 99FFCC

# 99FF99

# 99FF66

# 99FF33

# 99FF00

# 99CCFF

# 99CCCC

# 99CC99

# 99CC66

# 99CC33

# 99CC00

# 9999FF

# 9999CC

# 999999

# 999966

# 999933

# 999900

# 9966FF

# 9966CC

# 996699

# 996666

# 996633

# 996600

# 9933FF

# 9933CC

# 993399

# 993366

# 993333

# 993300

# 9900FF

# 9900CC

# 990099

# 990066

# 990033

# 990000

# 66FFFF

# 66FFCC

# 66FF99

# 66FF66

# 66FF33

# 66FF00

# 66CCFF

# 66CCCC

# 66CC99

# 66CC66

# 66CC33

# 66CC00

# 6699FF

# 6699CC

# 669999

# 669966

# 669933

# 669900

# 6666FF

# 6666CC

# 666699

# 666666

# 666633

# 666600

# 6633FF

# 6633CC

# 663399

# 663366

# 663333

# 663300

# 6600FF

# 6600CC

# 660099

# 660066

# 660033

# 660000

# 33FFFF

# 33FFCC

# 33FF99

# 33FF66

# 33FF33

# 33FF00

# 33CCFF

# 33CCCC

# 33CC99

# 33CC66

# 33CC33

# 33CC00

# 3399FF

# 3399CC

# 339999

# 339966

# 339933

# 339900

# 3366FF

# 3366CC

# 336699

# 336666

# 336633

# 336600

# 3333FF

# 3333CC

# 333399

# 333366

# 333333

# 333300

# 3300FF

# 3300CC

# 330099

# 330066

# 330033

# 330000

# 00FFFF

# 00FFCC

# 00FF99

# 00FF66

# 00FF33

# 00FF00

# 00CCFF

# 00CCCC

# 00CC99

# 00CC66

# 00CC33

# 00CC00

# 0099FF

# 0099CC

# 009999

# 009966

# 009933

# 009900

# 0066FF

# 0066CC

# 006699

# 006666

# 006633

# 006600

# 0033FF

# 0033CC

# 003399

# 003366

# 003333

# 003300

# 0000FF

# 0000CC

# 000099

# 000066

# 000033

# 000000


Alt Codes

Alt Codes : Combinaisons de touches au clavier
Chiffres à saisir en maintenant la touche [Alt] enfoncée
(les caractères n'apparaissent qu'après relachement de la touche [Alt])

¤ = [Alt] 15
¶ = [Alt] 20
§ = [Alt] 21
| = [Alt] 124
Ç = [Alt] 128
ü = [Alt] 129
é = [Alt] 130
 = [Alt] 131
ä = [Alt] 132
à = [Alt] 133
= [Alt] 134
ç = [Alt] 135
ê = [Alt] 136
ë = [Alt] 137
è = [Alt] 138
ï = [Alt] 139
î = [Alt] 140
ì = [Alt] 141
ô = [Alt] 147
ö = [Alt] 148
ò = [Alt] 149
û = [Alt] 150
ù = [Alt] 151
ÿ = [Alt] 152
Ö = [Alt] 153
Ü = [Alt] 154
¢ = [Alt] 155
£ = [Alt] 156
¥ = [Alt] 157
á = [Alt] 160
í = [Alt] 161
ó = [Alt] 162
ú = [Alt] 163
ñ = [Alt] 164
Ñ = [Alt] 165
ª = [Alt] 166
º = [Alt] 167
¿ = [Alt] 168
¬ = [Alt] 170
½ = [Alt] 171
¼ = [Alt] 172
¡ = [Alt] 173
« = [Alt] 174
» = [Alt] 175
¦ = [Alt] 179
ß = [Alt] 225
¶ = [Alt] 227
µ = [Alt] 230
± = [Alt] 241
÷ = [Alt] 246
° = [Alt] 248
" = [Alt] 249
· = [Alt] 250
² = [Alt] 253
¤ = [Alt] 271
¶ = [Alt] 276
§ = [Alt] 277
! = [Alt] 289
& = [Alt] 0133
= [Alt] 0134
! = [Alt] 0135
0 = [Alt] 0137
` = [Alt] 0138
9 = [Alt] 0139
R = [Alt] 0140
 = [Alt] 0141
" = [Alt] 0149
 = [Alt] 0150
 = [Alt] 0151
" = [Alt] 0153
a = [Alt] 0154
: = [Alt] 0155
S = [Alt] 0156
x = [Alt] 0159
¢ = [Alt] 0162
© = [Alt] 0169
ª = [Alt] 0170
« = [Alt] 0171
® = [Alt] 0174
¯ = [Alt] 0175
° = [Alt] 0176
± = [Alt] 0177
² = [Alt] 0178
³ = [Alt] 0179
· = [Alt] 0183
¸ = [Alt] 0184
¹ = [Alt] 0185
º = [Alt] 0186
» = [Alt] 0187
¼ = [Alt] 0188
½ = [Alt] 0189
¾ = [Alt] 0190
À = [Alt] 0192
Â = [Alt] 0194
Ã = [Alt] 0195
Å = [Alt] 0197
Æ = [Alt] 0198
È = [Alt] 0200
É = [Alt] 0201
Ê = [Alt] 0202
Ë = [Alt] 0203
Ì = [Alt] 0204
Î = [Alt] 0206
Ï = [Alt] 0207
Ð = [Alt] 0208
Ñ = [Alt] 0209
Ò = [Alt] 0210
Ô = [Alt] 0212
Ö = [Alt] 0214
Ø = [Alt] 0216
Ù = [Alt] 0217
Ú = [Alt] 0218
Û = [Alt] 0219
Ü = [Alt] 0220
Ý = [Alt] 0221
Þ = [Alt] 0222
ß = [Alt] 0223
à = [Alt] 0224
á = [Alt] 0225
ã = [Alt] 0227
ç = [Alt] 0231
è = [Alt] 0232
ê = [Alt] 0234
í = [Alt] 0237
ð = [Alt] 0240
ñ = [Alt] 0241
ò = [Alt] 0242
ó = [Alt] 0243
ô = [Alt] 0244
õ = [Alt] 0245
ö = [Alt] 0246
÷ = [Alt] 0247
ø = [Alt] 0248
ù = [Alt] 0249
ú = [Alt] 0250
û = [Alt] 0251
ü = [Alt] 0252
ý = [Alt] 0253
þ = [Alt] 0254
ÿ = [Alt] 0255


Iczelion's PE Tutorial 1: Overview of PE File Format

Tutorial 1: Overview of PE file format

This is the complete rewrite of the old PE tutorial no1 which I considered the worst tutorial I have ever written. So I decided to replace it with this new one.

PE stands for Portable Executable. It's the native file format of Win32. Its specification is derived somewhat from the Unix Coff (common object file format). The meaning of "portable executable" is that the file format is universal across win32 platform: the PE loader of every win32 platform recognizes and uses this file format even when Windows is running on CPU platforms other than Intel. It doesn't mean your PE executables would be able to port to other CPU platforms without change. Every win32 executable (except VxDs and 16-bit Dlls) uses PE file format. Even NT's kernel mode drivers use PE file format. Thus studying the PE file format gives you valuable insights into the structure of Windows.

Let's jump into the general outline of PE file format without further ado.

DOS MZ header
DOS stub
PE header
Section table
Section 1
Section 2
Section ...
Section n

The above picture is the general layout of a PE file. All PE files (even 32-bit DLLs) must start with a simple DOS MZ header. We usually aren't interested in this structure much. It's provided in the case when the program is run from DOS, so DOS can recognize it as a valid executable and can thus run the DOS stub which is stored next to the MZ header. The DOS stub is actually a valid EXE that is executed in case the operating system doesn't know about PE file format. It can simply display a string like "This program requires Windows" or it can be a full-blown DOS program depending on the intent of the programmer. We are also not very interested in DOS stub: it's usually provided by the assembler/compiler. In most case, it simply uses int 21h, service 9 to print a string saying "This program cannot run in DOS mode".

After the DOS stub comes the PE header. The PE header is a general term for the PE-related structure named IMAGE_NT_HEADERS. This structure contains many essential fields that are used by the PE loader. We will be quite familiar with it as you know more about PE file format. In the case the program is executed in the operating system that knows about PE file format, the PE loader can find the starting offset of the PE header from the DOS MZ header. Thus it can skip the DOS stub and go directly to the PE header which is the real file header.

The real content of the PE file is divided into blocks called sections. A section is nothing more than a block of data with common attributes such as code/data, read/write etc. You can think of a PE file as a logical disk. The PE header is the boot sector and the sections are files in the disk. The files can have different attributes such as read-only, system, hidden, archive and so on. I want to make it clear from this point onwards that the grouping of data into a section is done on the common attribute basis: not on logical basis. It doesn't matter how the code/data are used , if the data/code in the PE file have the same attribute, they can be lumped together in a section. You should not think of a section as "data", "code" or some other logical concepts: sections can contain both code and data provided that they have the same attribute. If you have a block of data that you want to be read-only, you can put that data in the section that is marked as read-only. When the PE loader maps the sections into memory, it examines the attributes of the sections and gives the memory block occupied by the sections the indicated attributes.

If we view the PE file format as a logical disk, the PE header as the boot sector and the sections as files, we still don't have enough information to find out where the files reside on the disk, ie. we haven't discussed the directory equivalent of the PE file format. Immediately following the PE header is the section table which is an array of structures. Each structure contains the information about each section in the PE file such as its attribute, the file offset, virtual offset. If there are 5 sections in the PE file, there will be exactly 5 members in this structure array. We can then view the section table as the root directory of the logical disk. Each member of the array is equvalent to the each directory entry in the root directory.

That's all about the physical layout of the PE file format. I'll summarize the major steps in loading a PE file into memory below:

  1. When the PE file is run, the PE loader examines the DOS MZ header for the offset of the PE header. If found, it skips to the PE header.
  2. The PE loader checks if the PE header is valid. If so, it goes to the end of the PE header.
  3. Immediately following the PE header is the section table. The PE header reads information about the sections and maps those sections into memory using file mapping. It also gives each section the attributes as specified in the section table.
  4. After the PE file is mapped into memory, the PE loader concerns itself with the logical parts of the PE file, such as the import table.

The above steps are oversimplification and are based on my own observation. There may be some inaccuracies but it should give you the clear picture of the process.

You should download LUEVELSMEYER's description about PE file format. It's very detailed and you should keep it as a reference.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE Tutorial 2: Detecting a Valid PE File

Tutorial 2: Detecting a Valid PE File

In this tutorial, we will learn how to check if a given file is a valid PE file.
Download the example.

Theory:

How can you verify if a given file is a PE file? That question is difficult to answer. That depends on the length that you want to go to do that. You can verify every data structure defined in the PE file format or you are satisfied with verifying only the crucial ones. Most of the time, it's pretty pointless to verify every single structure in the files. If the crucial structures are valid, we can assume that the file is a valid PE. And we will use that assumption.

The essential structure we will verify is the PE header itself. So we need to know a little about it, programmatically. The PE header is actually a structure called IMAGE_NT_HEADERS. It has the following definition:

IMAGE_NT_HEADERS STRUCT
Signature dd ?
FileHeader IMAGE_FILE_HEADER <>
OptionalHeader IMAGE_OPTIONAL_HEADER32 <>
IMAGE_NT_HEADERS ENDS

Signature is a dword that contains the value 50h, 45h, 00h, 00h. In more human term, it contains the text "PE" followed by two terminating zeroes. This member is the PE signature so we will use it in verifying if a given file is a valid PE one.
FileHeader is a structure that contains information about the physical layout of the PE file such as the number of sections, the machine the file is targeted and so on.
OptionalHeader is a structure that contains information about the logical layout of the PE file. Despite the "Optional" in its name, it's always present.

Our goal is now clear. If value of the signature member of the IMAGE_NT_HEADERS is equal to "PE" followed by two zeroes, then the file is a valid PE. In fact, for comparison purpose, Microsoft has defined a constant named IMAGE_NT_SIGNATURE which we can readily use.

IMAGE_DOS_SIGNATURE equ 5A4Dh
IMAGE_OS2_SIGNATURE equ 454Eh
IMAGE_OS2_SIGNATURE_LE equ 454Ch
IMAGE_VXD_SIGNATURE equ 454Ch
IMAGE_NT_SIGNATURE equ 4550h

The next question: how can we know where the PE header is? The answer is simple: the DOS MZ header contains the file offset of the PE header. The DOS MZ header is defined as IMAGE_DOS_HEADER structure. You can check it out in windows.inc. The e_lfanew member of the IMAGE_DOS_HEADER structure contains the file offset of the PE header.

The steps are now as follows:

  1. Verify if the given file has a valid DOS MZ header by comparing the first word of the file with the value IMAGE_DOS_SIGNATURE.
  2. If the file has a valid DOS header, use the value in e_lfanew member to find the PE header
  3. Comparing the first word of the PE header with the value IMAGE_NT_HEADER. If both values match, then we can assume that the file is a valid PE.

Example:

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\comdlg32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\comdlg32.lib

SEH struct
PrevLink dd ?    ; the address of the previous seh structure
CurrentHandler dd ?    ; the address of the exception handler
SafeOffset dd ?    ; The offset where it's safe to continue execution
PrevEsp dd ?      ; the old value in esp
PrevEbp dd ?     ; The old value in ebp
SEH ends

.data
AppName db "PE tutorial no.2",0
ofn OPENFILENAME <>
FilterString db "Executable Files (*.exe, *.dll)",0,"*.exe;*.dll",0
                 db "All Files",0,"*.*",0,0
FileOpenError db "Cannot open the file for reading",0
FileOpenMappingError db "Cannot open the file for memory mapping",0
FileMappingError db "Cannot map the file into memory",0
FileValidPE db "This file is a valid PE",0
FileInValidPE db "This file is not a valid PE",0

.data?
buffer db 512 dup(?)
hFile dd ?
hMapping dd ?
pMapping dd ?
ValidPE dd ?

.code
start proc
LOCAL seh:SEH
mov ofn.lStructSize,SIZEOF ofn
mov ofn.lpstrFilter, OFFSET FilterString
mov ofn.lpstrFile, OFFSET buffer
mov ofn.nMaxFile,512
mov ofn.Flags, OFN_FILEMUSTEXIST or OFN_PATHMUSTEXIST or OFN_LONGNAMES or OFN_EXPLORER or OFN_HIDEREADONLY
invoke GetOpenFileName, ADDR ofn
.if eax==TRUE
    invoke CreateFile, addr buffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
    .if eax!=INVALID_HANDLE_VALUE
       mov hFile, eax
       invoke CreateFileMapping, hFile, NULL, PAGE_READONLY,0,0,0
       .if eax!=NULL
          mov hMapping, eax
          invoke MapViewOfFile,hMapping,FILE_MAP_READ,0,0,0
          .if eax!=NULL
             mov pMapping,eax
             assume fs:nothing
             push fs:[0]
             pop seh.PrevLink
             mov seh.CurrentHandler,offset SEHHandler
             mov seh.SafeOffset,offset FinalExit
             lea eax,seh
             mov fs:[0], eax
             mov seh.PrevEsp,esp
             mov seh.PrevEbp,ebp
             mov edi, pMapping
             assume edi:ptr IMAGE_DOS_HEADER
             .if [edi].e_magic==IMAGE_DOS_SIGNATURE
                add edi, [edi].e_lfanew
                assume edi:ptr IMAGE_NT_HEADERS
                .if [edi].Signature==IMAGE_NT_SIGNATURE
                   mov ValidPE, TRUE
                .else
                   mov ValidPE, FALSE
                .endif
             .else
                 mov ValidPE,FALSE
             .endif
FinalExit:
             .if ValidPE==TRUE
                 invoke MessageBox, 0, addr FileValidPE, addr AppName, MB_OK+MB_ICONINFORMATION
             .else
                invoke MessageBox, 0, addr FileInValidPE, addr AppName, MB_OK+MB_ICONINFORMATION
             .endif
             push seh.PrevLink
             pop fs:[0]
             invoke UnmapViewOfFile, pMapping
          .else
             invoke MessageBox, 0, addr FileMappingError, addr AppName, MB_OK+MB_ICONERROR
          .endif
          invoke CloseHandle,hMapping
       .else
          invoke MessageBox, 0, addr FileOpenMappingError, addr AppName, MB_OK+MB_ICONERROR
       .endif
       invoke CloseHandle, hFile
    .else
       invoke MessageBox, 0, addr FileOpenError, addr AppName, MB_OK+MB_ICONERROR
    .endif
.endif
invoke ExitProcess, 0
start endp

SEHHandler proc C uses edx pExcept:DWORD, pFrame:DWORD, pContext:DWORD, pDispatch:DWORD
    mov edx,pFrame
    assume edx:ptr SEH
    mov eax,pContext
    assume eax:ptr CONTEXT
    push [edx].SafeOffset
    pop [eax].regEip
    push [edx].PrevEsp
    pop [eax].regEsp
    push [edx].PrevEbp
    pop [eax].regEbp
    mov ValidPE, FALSE
    mov eax,ExceptionContinueExecution
    ret
SEHHandler endp
end start

Analysis:

The program opens a file and checks if the DOS header is valid, if it is, it checks the PE header if it's valid. If it is, then it assumes the file is a valid PE. In this example, I use structured exception handling (SEH) so that we don't have to check for every possible error: if a fault occurs, we assume that it's because the file is not a valid PE thus giving our program wrong information. Windows itself uses SEH heavily in its parameter validation routines. If you're interested in SEH, read the article by Jeremy Gordon.

The program displays an open file common dialog to the user and when the user chooses an executable file, it opens the file and maps it into memory. Before it goes on with the verification, it sets up a SEH:

   assume fs:nothing
   push fs:[0]
   pop seh.PrevLink
   mov seh.CurrentHandler,offset SEHHandler
   mov seh.SafeOffset,offset FinalExit
   lea eax,seh
   mov fs:[0], eax
   mov seh.PrevEsp,esp
   mov seh.PrevEbp,ebp

We start by assuming the use of fs register as nothing. This must be done because MASM assumes the use of fs register to ERROR. Next we store the address of the previous SEH handler in our structure for use by Windows. We store the address of our SEH handler, the address where the execution can safely resume if a fault occurs, the current values of esp and ebp so that our SEH handler can get the state of the stack back to normal before it resumes the execution of our program.

   mov edi, pMapping
   assume edi:ptr IMAGE_DOS_HEADER
   .if [edi].e_magic==IMAGE_DOS_SIGNATURE

After we are done with setting up SEH, we continue with the verification. We put the address of the first byte of the target file in edi, which is the first byte of the DOS header. For ease of comparison, we tell the assembler that it can assume edi as pointing to the IMAGE_DOS_HEADER structure (which is the truth). We then compare the first word of the DOS header with the string "MZ" which is defined as a constant in windows.inc named IMAGE_DOS_SIGNATURE. If the comparison is ok, we continue to the PE header. If not, we set the value in ValidPE to FALSE, meaning that the file is not a valid PE.

      add edi, [edi].e_lfanew
      assume edi:ptr IMAGE_NT_HEADERS
      .if [edi].Signature==IMAGE_NT_SIGNATURE
         mov ValidPE, TRUE
      .else
         mov ValidPE, FALSE
      .endif

To get to the PE header, we need the value in e_lfanew of the DOS header. This field contains the file offset of the PE header, relative to the file beginning. Thus we add this value to edi and we get to the first byte of the PE header. It's this place that a fault may occur. If the file is really not a PE file, the value in e_lfanew will be incorrect and thus using it amounts to using a wild pointer. If we don't use SEH, we must check the value of the e_lfanew against the file size which is ugly. If all goes well, we compare the first dword of the PE header with the string "PE". Again there is a handy constant named IMAGE_NT_SIGNATURE which we can use. If the result of comparison is true, we assume the file is a valid PE.
If the value in e_lfanew is incorrect, a fault may occur and our SEH handler will get control. It simply restores the stack pointer, bsae pointer and resumes the execution at the safe offset which is at the FinalExit label.

FinalExit:
   .if ValidPE==TRUE
      invoke MessageBox, 0, addr FileValidPE, addr AppName, MB_OK+MB_ICONINFORMATION
   .else
      invoke MessageBox, 0, addr FileInValidPE, addr AppName, MB_OK+MB_ICONINFORMATION
   .endif

The above code is simplicity itself. It checks the value in ValidPE and displays a message to the user accordingly.

   push seh.PrevLink
   pop fs:[0]

When the SEH is no longer used, we dissociate it from the SEH chain.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE tutorial 3: File Header

Tutorial 3: File Header

In this tutorial, we will study the file header portion of the PE header.

Let's summarize what we have learned so far:

  • DOS MZ header is called IMAGE_DOS_HEADER. Only two of its members are important to us: e_magic which contains the string "MZ" and e_lfanew which contains the file offset of the PE header.
  • We use the value in e_magic to check if the file has a valid DOS header by comparing it to the value IMAGE_DOS_SIGNATURE. If both values match, we can assume that the file has a valid DOS header.
  • In order to go to the PE header, we must move the file pointer to the offset specified by the value in e_lfanew.
  • The first dword of the PE header should contain the string "PE" followed by two zeroes. We compare the value in this dword to the value IMAGE_NT_SIGNATURE. If they match, then we can assume that the PE header is valid.

We will learn more about the PE header in this tutorial. The official name of the PE header is IMAGE_NT_HEADERS. To refresh your memory, I show it below.

IMAGE_NT_HEADERS STRUCT
Signature dd ?
FileHeader IMAGE_FILE_HEADER <>
OptionalHeader IMAGE_OPTIONAL_HEADER32 <>
IMAGE_NT_HEADERS ENDS

Signature is the PE signature, "PE" followed by two zeroes. You already know and use this member.
FileHeader is a structure that contains the information about the physical layout/properies of the PE file in general.
OptionalHeader is also a structure that contains the information about the logical layout inside the PE file.

The most interesting information is in OptionalHeader. However, some fields in FileHeader are also important. We will learn about FileHeader in this tutorial so we can move to study OptionalHeader in the next tutorials.

IMAGE_FILE_HEADER STRUCT
Machine WORD ?
NumberOfSections WORD ?
TimeDateStamp dd ?
PointerToSymbolTable dd ?
NumberOfSymbols dd ?
SizeOfOptionalHeader WORD ?
Characteristics WORD ?
IMAGE_FILE_HEADER ENDS

Field name | Meanings
Machine | The CPU platform the file is intended for. For Intel platform, the value is IMAGE_FILE_MACHINE_I386 (14Ch). I tried to use 14Dh and 14Eh as stated in the pe.txt by LUEVELSMEYER but Windows refused to run it. This field is rarely of interest to us except as a quick way of preventing a program to be executed.
NumberOfSections | The number of sections in the file. We will need to modify the value in this member if we add or delete a section from the file.
TimeDateStamp | The date and time the file is created. Not useful to us.
PointerToSymbolTable | used for debugging.
NumberOfSymbols | used for debugging.
SizeOfOptionalHeader | The size of the OptionalHeader member that immediately follows this structure. Must be set to a valid value.
Characteristics | Contains flags for the file, such as whether this file is an exe or a dll.

In summary, only three members are somewhat useful to us: Machine, NumberOfSections and Characteristics. You would normally not change the values of Machine and Characteristics but you must use the value in NumberOfSections when you're walking the section table.
I'm jumping the gun here but in order to illustrate the use of NumberOfSections, I need to digress briefly to the section table.

The section table is an array of structures. Each structure contains the information of a section. Thus if there are 3 sections, there will be 3 members in this array. You need the value in NumberOfSections so you know how many members there are in the array. You would think that checking for the structure with all zeroes in its members would help. Windows does use this approach. You can verify this fact by setting the value in NumberOfSections to a value higher than the real value and Windows still runs the file without problem. From my observation, I think Windows reads the value in NumberOfSections and examines each structure in the section table. If it finds a structure that contains all zeroes, it terminates the search. Else it would process until the number of structures specified in NumberOfSections is met. Why can't we ignore the value in NumberOfSections? Several reasons. The PE specification doesn't specify that the section table array must end with an all-zero structure. Thus there may be a situation where the last array member is contiguous to the first section, without empty space at all. Another reason has to do with bound imports. The new-style binding puts the information immediately following the section table's last structure array member. Thus you still need NumberOfSections.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE Tutorial 4: Optional Header

Tutorial 4: Optional Header

We have learned about the DOS header and some members of the PE header. Here's the last, the biggest and probably the most important member of the PE header, the optional header.

To refresh your memory, the optional header is a structure that is the last member of IMAGE_NT_HEADERS. It contains information about the logical layout in the PE file. There are 31 fields in this structure. Some of them are crucial and some are not useful. I'll explain only those fields that are really useful.

There is a word that's used frequently in relation to PE file format: RVA
RVA stands for relative virtual address. You know what virtual address is. RVA is a daunting term for such a simple concept. Simply put, an RVA is a distance from a reference point in the virtual address space. I bet you're familiar with file offset: an RVA is exactly the same thing as file offset. However, it's relative to a point in virtual address space, not a file. I'll show you an example. If a PE file loads at 400000h in the virtual address (VA) space and the program starts execution at the virtual address 401000h, we can say that the program starts execution at RVA 1000h. An RVA is relative to the starting VA of the module.
Why does the PE file format use RVA? It's to help reduce the load of the PE loader. Since a module can be relocated anywhere in the virtual address space, it would be a hell for the PE loader to fix every relocatable items in the module. In contrast, if all relocatable items in the file use RVA, there is no need for the PE loader to fix anything: it simply relocates the whole module to a new starting VA. It's like the concept of relative path and absolute path: RVA is akin to relative path, VA is like absolute path.

Field | Meanings
AddressOfEntryPoint | It's the RVA of the first instruction that will be executed when the PE loader is ready to run the PE file. If you want to divert the flow of execution right from the start, you need to change the value in this field to a new RVA and the instruction at the new RVA will be executed first.
ImageBase | It's the preferred load address for the PE file. For example, if the value in this field is 400000h, the PE loader will try to load the file into the virtual address space starting at 400000h. The word "preferred" means that the PE loader may not load the file at that address if some other module already occupied that address range.
SectionAlignment | The granularity of the alignment of the sections in memory. For example, if the value in this field is 4096 (1000h), each section must start at multiples of 4096 bytes. If the first section is at 401000h and its size is 10 bytes, the next section must be at 402000h even if the address space between 401000h and 402000h will be mostly unused.
FileAlignment | The granularity of the alignment of the sections in the file. For example, if the value in this field is 512 (200h), each section must start at multiples of 512 bytes. If the first section is at file offset 200h and the size is 10 bytes, the next section must be located at file offset 400h: the space between file offsets 522 and 1024 is unused/undefined.
MajorSubsystemVersion MinorSubsystemVersion | The win32 subsystem version. If the PE file is designed for Win32, the subsystem version must be 4.0 else the dialog won't have 3-D look.
SizeOfImage | The overall size of the PE image in memory. It's the sum of all headers and sections aligned to SectionAlignment.
SizeOfHeaders | The size of all headers+section table. In short, this value is equal to the file size minus the combined size of all sections in the file. You can also use this value as the file offset of the first section in the PE file.
Subsystem | Tell in which of the NT subsystem the PE file is intended for. For most win32 progs, only two values are used: Windows GUI and Windows CUI (console).
DataDirectory | An array of IMAGE_DATA_DIRECTORY structures. Each structure gives the RVA of an important data structure in the PE file such as the import address table.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE Tutorial 5: Section Table

Tutorial 5: Section Table

Download the example.

Theory:

Up to this tutorial, we learned about the DOS header, the PE header. What remains is the section table. A section table is actually an array of structure immediately following the PE header. The number of the array members is determined by NumberOfSections field in the file header (IMAGE_FILE_HEADER) structure. The structure is called IMAGE_SECTION_HEADER.

IMAGE_SIZEOF_SHORT_NAME equ 8

IMAGE_SECTION_HEADER STRUCT
Name1 db IMAGE_SIZEOF_SHORT_NAME dup(?)
union Misc
PhysicalAddress dd ?
VirtualSize dd ?
ends
VirtualAddress dd ?
SizeOfRawData dd ?
PointerToRawData dd ?
PointerToRelocations dd ?
PointerToLinenumbers dd ?
NumberOfRelocations dw ?
NumberOfLinenumbers dw ?
Characteristics dd ?
IMAGE_SECTION_HEADER ENDS

Again, not all members are useful. I'll describe only the ones that are really important.

Field | Meanings
Name1 | Actually the name of this field is "name" but the word "name" is an MASM keyword so we have to use "Name1" instead. This member contains the name of the section. Note that the maximum length is 8 bytes. The name is just a label, nothing more. You can use any name or even leave this field blank. Note that there is no mention of the terminating null. The name is not an ASCIIZ string so don't expect it to be terminated with a null.
VirtualAddress | The RVA of the section. The PE loader examines and uses the value in this field when it's mapping the section into memory. Thus if the value in this field is 1000h and the PE file is loaded at 400000h, the section will be loaded at 401000h.
SizeOfRawData | The size of the section's data rounded up to the next multiple of file alignment. The PE loader examines the value in this field so it knows how many bytes in the section it should map into memory.
PointerToRawData | The file offset of the beginning of the section. The PE loader uses the value in this field to find where the data in the section is in the file.
Characteristics | Contains flags such as whether this section contains executable code, initialized data, uninitialized data, can it be written to or read from.

Now that we know about IMAGE_SECTION_HEADER structure, let's see how we can emulate the PE loader's job:

  1. Read NumberOfSections in IMAGE_FILE_HEADER so we know how many sections there are in the file.
  2. Use the value in SizeOfHeaders as the file offset of the section table and moves the file pointer to that offset.
  3. Walk the structure array, examining each member.
  4. For each structure, we obtain the value in PointerToRawData and move the file pointer to that offset. Then we read the value in SizeOfRawData so we know how many bytes we should map into memory. Read the value in VirtualAddress and add the value in ImageBase to it to get the virtual address the section should start from. And then we are ready to map the section into memory and mark the attribute of the memory according to the flags in Characteristics.
  5. Walk the array until all the sections are processed.

Note that we didn't make use the the name of the section: it's not really necessary.

Example:

This example opens a PE file and walks the section table, showing the information about the sections in a listview control.

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\comdlg32.inc
include \masm32\include\user32.inc
include \masm32\include\comctl32.inc
includelib \masm32\lib\comctl32.lib
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\comdlg32.lib

IDD_SECTIONTABLE equ 104
IDC_SECTIONLIST equ 1001

SEH struct
PrevLink dd ? ; the address of the previous seh structure
CurrentHandler dd ? ; the address of the new exception handler
SafeOffset dd ? ; The offset where it's safe to continue execution
PrevEsp dd ? ; the old value in esp
PrevEbp dd ? ; The old value in ebp
SEH ends

.data
AppName db "PE tutorial no.5",0
ofn OPENFILENAME <>
FilterString db "Executable Files (*.exe, *.dll)",0,"*.exe;*.dll",0
             db "All Files",0,"*.*",0,0
FileOpenError db "Cannot open the file for reading",0
FileOpenMappingError db "Cannot open the file for memory mapping",0
FileMappingError db "Cannot map the file into memory",0
FileInValidPE db "This file is not a valid PE",0
template db "%08lx",0
SectionName db "Section",0
VirtualSize db "V.Size",0
VirtualAddress db "V.Address",0
SizeOfRawData db "Raw Size",0
RawOffset db "Raw Offset",0
Characteristics db "Characteristics",0

.data?
hInstance dd ?
buffer db 512 dup(?)
hFile dd ?
hMapping dd ?
pMapping dd ?
ValidPE dd ?
NumberOfSections dd ?

.code
start proc
LOCAL seh:SEH
   invoke GetModuleHandle,NULL
   mov hInstance,eax
   mov ofn.lStructSize,SIZEOF ofn
   mov ofn.lpstrFilter, OFFSET FilterString
   mov ofn.lpstrFile, OFFSET buffer
   mov ofn.nMaxFile,512
   mov ofn.Flags, OFN_FILEMUSTEXIST or OFN_PATHMUSTEXIST or OFN_LONGNAMES or OFN_EXPLORER or OFN_HIDEREADONLY
   invoke GetOpenFileName, ADDR ofn
   .if eax==TRUE
      invoke CreateFile, addr buffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
      .if eax!=INVALID_HANDLE_VALUE
         mov hFile, eax
         invoke CreateFileMapping, hFile, NULL, PAGE_READONLY,0,0,0
         .if eax!=NULL
            mov hMapping, eax
            invoke MapViewOfFile,hMapping,FILE_MAP_READ,0,0,0
            .if eax!=NULL
               mov pMapping,eax
               assume fs:nothing
               push fs:[0]
               pop seh.PrevLink
               mov seh.CurrentHandler,offset SEHHandler
               mov seh.SafeOffset,offset FinalExit
               lea eax,seh
               mov fs:[0], eax
               mov seh.PrevEsp,esp
               mov seh.PrevEbp,ebp
               mov edi, pMapping
               assume edi:ptr IMAGE_DOS_HEADER
               .if [edi].e_magic==IMAGE_DOS_SIGNATURE
                  add edi, [edi].e_lfanew
                  assume edi:ptr IMAGE_NT_HEADERS
                  .if [edi].Signature==IMAGE_NT_SIGNATURE
                     mov ValidPE, TRUE
                  .else
                     mov ValidPE, FALSE
                  .endif
               .else
                  mov ValidPE,FALSE
               .endif
FinalExit:
               push seh.PrevLink
               pop fs:[0]
               .if ValidPE==TRUE
                  call ShowSectionInfo
               .else
                  invoke MessageBox, 0, addr FileInValidPE, addr AppName, MB_OK+MB_ICONINFORMATION
               .endif
               invoke UnmapViewOfFile, pMapping
           .else
               invoke MessageBox, 0, addr FileMappingError, addr AppName, MB_OK+MB_ICONERROR
          .endif
          invoke CloseHandle,hMapping
       .else
          invoke MessageBox, 0, addr FileOpenMappingError, addr AppName, MB_OK+MB_ICONERROR
       .endif
       invoke CloseHandle, hFile
    .else
       invoke MessageBox, 0, addr FileOpenError, addr AppName, MB_OK+MB_ICONERROR
    .endif
  .endif
  invoke ExitProcess, 0
  invoke InitCommonControls
start endp

SEHHandler proc C uses pExcept:DWORD,pFrame:DWORD,pContext:DWORD,pDispatch:DWORD
   mov edx,pFrame
   assume edx:ptr SEH
   mov eax,pContext
   assume eax:ptr CONTEXT
   push [edx].SafeOffset
   pop [eax].regEip
   push [edx].PrevEsp
   pop [eax].regEsp
   push [edx].PrevEbp
   pop [eax].regEbp
   mov ValidPE, FALSE
   mov eax,ExceptionContinueExecution
   ret
SEHHandler endp

DlgProc proc uses edi esi hDlg:DWORD, uMsg:DWORD, wParam:DWORD, lParam:DWORD
   LOCAL lvc:LV_COLUMN
   LOCAL lvi:LV_ITEM
   .if uMsg==WM_INITDIALOG
      mov esi, lParam
      mov lvc.imask,LVCF_FMT or LVCF_TEXT or LVCF_WIDTH or LVCF_SUBITEM
      mov lvc.fmt,LVCFMT_LEFT
      mov lvc.lx,80
      mov lvc.iSubItem,0
      mov lvc.pszText,offset SectionName
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,0,addr lvc inc lvc.iSubItem
      mov lvc.fmt,LVCFMT_RIGHT
      mov lvc.pszText,offset VirtualSize
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,1,addr lvc
      inc lvc.iSubItem
      mov lvc.pszText,offset VirtualAddress
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,2,addr lvc
      inc lvc.iSubItem
      mov lvc.pszText,offset SizeOfRawData
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,3,addr lvc
      inc lvc.iSubItem
      mov lvc.pszText,offset RawOffset
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,4,addr lvc
      inc lvc.iSubItem
      mov lvc.pszText,offset Characteristics
      invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTCOLUMN,5,addr lvc
      mov ax, NumberOfSections
      movzx eax,ax
      mov edi,eax
      mov lvi.imask,LVIF_TEXT
      mov lvi.iItem,0
      assume esi:ptr IMAGE_SECTION_HEADER
      .while edi>0
         mov lvi.iSubItem,0
         invoke RtlZeroMemory,addr buffer,9
         invoke lstrcpyn,addr buffer,addr [esi].Name1,8
         lea eax,buffer
         mov lvi.pszText,eax
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTITEM,0,addr lvi
         invoke wsprintf,addr buffer,addr template,[esi].Misc.VirtualSize
         lea eax,buffer
         mov lvi.pszText,eax
         inc lvi.iSubItem
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_SETITEM,0,addr lvi
         invoke wsprintf,addr buffer,addr template,[esi].VirtualAddress
         lea eax,buffer
         mov lvi.pszText,eax
         inc lvi.iSubItem
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_SETITEM,0,addr lvi
         invoke wsprintf,addr buffer,addr template,[esi].SizeOfRawData
         lea eax,buffer
         mov lvi.pszText,eax
         inc lvi.iSubItem
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_SETITEM,0,addr lvi
         invoke wsprintf,addr buffer,addr template,[esi].PointerToRawData
         lea eax,buffer
         mov lvi.pszText,eax
         inc lvi.iSubItem
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_SETITEM,0,addr lvi
         invoke wsprintf,addr buffer,addr template,[esi].Characteristics
         lea eax,buffer
         mov lvi.pszText,eax
         inc lvi.iSubItem
         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_SETITEM,0,addr lvi
         inc lvi.iItem
         dec edi
         add esi, sizeof IMAGE_SECTION_HEADER
      .endw
   .elseif
      uMsg==WM_CLOSE
         invoke EndDialog,hDlg,NULL
   .else
      mov eax,FALSE
      ret
   .endif
   mov eax,TRUE
   ret
DlgProc endp

ShowSectionInfo proc uses edi
   mov edi, pMapping
   assume edi:ptr IMAGE_DOS_HEADER
   add edi, [edi].e_lfanew
   assume edi:ptr IMAGE_NT_HEADERS
   mov ax,[edi].FileHeader.NumberOfSections
   movzx eax,ax
   mov NumberOfSections,eax
   add edi,sizeof IMAGE_NT_HEADERS
   invoke DialogBoxParam, hInstance, IDD_SECTIONTABLE,NULL, addr DlgProc, edi
   ret
ShowSectionInfo endp
end start

Analysis:

This example reuses the code of the example in PE tutorial 2. After it verifies that the file is a valid PE, it calls a function, ShowSectionInfo.

ShowSectionInfo proc uses edi
   mov edi, pMapping
   assume edi:ptr IMAGE_DOS_HEADER
   add edi, [edi].e_lfanew
   assume edi:ptr IMAGE_NT_HEADERS

We use edi as the pointer to the data in the PE file. At first, we initialize it to the value of pMapping which is the address of the DOS header. Then we add the value in e_lfanew to it so it now contains the address of the PE header.

   mov ax,[edi].FileHeader.NumberOfSections
   mov NumberOfSections,ax

Since we need to walk the section table, we must obtain the number of sections in this file. That's the value in NumberOfSections member of the file header. Don't forget that this member is of word size.

   add edi,sizeof IMAGE_NT_HEADERS

Edi currently contains the address of the PE header. Adding the size of the PE header to it will make it point at the section table.

   invoke DialogBoxParam, hInstance, IDD_SECTIONTABLE,NULL, addr DlgProc, edi

Call DialogBoxParam to show the dialog box containing the listview control. Note that we pass the address of the section table as its last parameter. This value will be available in lParam during WM_INITDIALOG message.

In the dialog box procedure, in response to WM_INITDIALOG message, we store the value of lParam (address of the section table) in esi, the number of sections in edi and then dress up the listview control. When everything is ready, we enter a loop which will insert the info about each section into the listview control. This part is very simple.

      .while edi>0
         mov lvi.iSubItem,0

Put this string in the first column.

         invoke RtlZeroMemory,addr buffer,9
         invoke lstrcpyn,addr buffer,addr [esi].Name1,8
         lea eax,buffer
         mov lvi.pszText,eax

We will display the name of the section but we must convert it to an ASCIIZ string first.

         invoke SendDlgItemMessage,hDlg,IDC_SECTIONLIST,LVM_INSERTITEM,0,addr lvi

Then we display it in the first column.
We continue with this scheme until the last value we want to display for this section is displayed. Then we must move to the next structure.

         dec edi
         add esi, sizeof IMAGE_SECTION_HEADER
      .endw

We decrement the value in edi for each section processed. And we add the size of IMAGE_SECTION_HEADER to esi so it contains the address of the next IMAGE_SECTION_HEADER structure.

The steps in walking the section table are:

  1. Verify that the file is a valid PE
  2. Go to the beginning of the PE header
  3. Obtain the number of sections from NumberOfSections field in the file header.
  4. Go to the section table either by adding ImageBase to SizeOfHeaders or by adding the address of the PE header to the size of the PE header. (The section table immediately follows the PE header). If you don't use file mapping, you need to move the file pointer to the section table using SetFilePointer. The file offset of the section table is in SizeOfHeaders.(SizeOfHeaders is a member of IMAGE_OPTIONAL_HEADER)
  5. Process each IMAGE_SECTION_HEADER structure.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE Tutorial 6: Import Table

Tutorial 6: Import Table

We will learn about import table in this tutorial. Let me warn you first. This tutorial is a long and difficult one for those who aren't familiar with the import table. You may need to read this tutorial several times and may even have to examine the related structures under a debugger.

Download the example.

Theory:

First of all, you should know what an import function is. An import function is a function that is not in the caller's module but is called by the module, thus the name "import". The import functions actually reside in one or more DLLs. Only the information about the functions is kept in the caller's module. That information includes the function names and the names of the DLLs in which they reside.
Now how can we find out where in the PE file the information is kept? We must turn to the data directory for the answer. I'll refresh your memory a bit. Below is the PE header:

IMAGE_NT_HEADERS STRUCT
   Signature dd ?
   FileHeader IMAGE_FILE_HEADER <>
   OptionalHeader IMAGE_OPTIONAL_HEADER <>
IMAGE_NT_HEADERS ENDS

The last member of the optional header is the data directory:

IMAGE_OPTIONAL_HEADER32 STRUCT
   ....
   LoaderFlags dd ?
   NumberOfRvaAndSizes dd ?
   DataDirectory IMAGE_DATA_DIRECTORY 16 dup(<>)
IMAGE_OPTIONAL_HEADER32 ENDS

The data directory is an array of IMAGE_DATA_DIRECTORY structure. A total of 16 members. If you remember the section table as the root directory of the sections in a PE file, you should also think of the data directory as the root directory of the logical components stored inside those sections. To be precise, the data directory contains the locations and sizes of the important data structures in the PE file. Each member contains information about an important data structure.

Member | Info inside
0 | Export symbols
1 | Import symbols
2 | Resources
3 | Exception
4 | Security
5 | Base relocation
6 | Debug
7 | Copyright string
8 | Unknown
9 | Thread local storage (TLS)
10 | Load configuration
11 | Bound Import
12 | Import Address Table
13 | Delay Import
14 | COM descriptor

Only the members painted in gold are known to me. Now that you know what each member of the data directory contains, we can learn about the member in detail. Each member of the data directory is a structure called IMAGE_DATA_DIRECTORY which has the following definition:

IMAGE_DATA_DIRECTORY STRUCT
  VirtualAddress dd ?
  isize dd ?
IMAGE_DATA_DIRECTORY ENDS

VirtualAddress is actually the relative virtual address (RVA) of the data structure. For example, if this structure is for import symbols, this field contains the RVA of the IMAGE_IMPORT_DESCRIPTOR array.
isize contains the size in bytes of the data structure referred to by VirtualAddress.

Here's the general scheme on finding important data structures in a PE file:

  1. From the DOS header, you go to the PE header
  2. Obtain the address of the data directory in the optional header.
  3. Multiply the size of IMAGE_DATA_DIRECTORY with the member index you want: for example if you want to know where the import symbols are, you must multiply the size of IMAGE_DATA_DIRECTORY (8 bytes) with 1.
  4. Add the result to the address of the data directory and you have the address of the IMAGE_DATA_DIRECTORY structure that contains the info about the desired data structure.

Now we will enter into the real discussion about the import table. The address of the import table is contained in the VirtualAddress field of the second member of the data directory. The import table is actually an array of IMAGE_IMPORT_DESCRIPTOR structures. Each structure contains information about a DLL the PE file imports symbols from. For example, if the PE file imports functions from 10 different DLLs, there will be 10 members in this array. The array is terminated by the member which contain all zeroes. Now we can examine the structure in detail:

IMAGE_IMPORT_DESCRIPTOR STRUCT
  union
    Characteristics dd ?
    OriginalFirstThunk dd ?
  ends
  TimeDateStamp dd ?
  ForwarderChain dd ?
  Name1 dd ?
  FirstThunk dd ?
IMAGE_IMPORT_DESCRIPTOR ENDS

The first member of this structure is a union. Actually, the union only provides the alias for OriginalFirstThunk, so you can call it "Characteristics". This member contains the the RVA of an array of IMAGE_THUNK_DATA structures.
What is IMAGE_THUNK_DATA? It's a union of dword size. Usually, we interpret it as the pointer to an IMAGE_IMPORT_BY_NAME structure. Note that IMAGE_THUNK_DATA contains the pointer to an IMAGE_IMPORT_BY_NAME structure: not the structure itself.
Look at it this way: There are several IMAGE_IMPORT_BY_NAME structures. We collect the RVA of those structures (IMAGE_THUNK_DATAs) into an array, terminate it with 0. Then we put the RVA of the array into OriginalFirstThunk.
The IMAGE_IMPORT_BY_NAME structure contains information about an import function. Now let's see what IMAGE_IMPORT_BY_NAME structure looks like:

IMAGE_IMPORT_BY_NAME STRUCT
  Hint dw ?
  Name1 db ?
IMAGE_IMPORT_BY_NAME ENDS

Hint contains the index into the export table of the DLL the function resides in. This field is for use by the PE loader so it can look up the function in the DLL's export table quickly.This value is not essential and some linkers may set the value in this field to 0.
Name1 contains the name of the import function. The name is an ASCIIZ string. Note that Name1's size is defined as byte but it's really a variable-sized field. It's just that there is no way to represent a variable-sized field in a structure. The structure is provided so that you can refer to the data structure with descriptive names.

TimeDateStamp and ForwarderChain are advanced stuff: We will talk about them after you have firm grasp of the other members.

Name1 contains the RVA to the name of the DLL, in short, the pointer to the name of the DLL. The string is an ASCIIZ one.

FirstThunk is very similar to OriginalFirstThunk, ie. it contains an RVA of an array of IMAGE_THUNK_DATA structures(a different array though).
Ok, if you're still confused, look at it this way: There are several IMAGE_IMPORT_BY_NAME structures. You create two arrays, then fill them with the RVAs of those IMAGE_IMPORT_BY_NAME structures, so both arrays contain exactly the same values (i.e. exact duplicate). Now you assign the RVA of the first array to OriginalFirstThunk and the RVA of the second array to FirstThunk.

OriginalFirstThunk IMAGE_IMPORT_BY_NAME FirstThunk

|

|
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
...
IMAGE_THUNK_DATA
--->
--->
--->
--->
--->
--->
Function 1
Function 2
Function 3
Function 4
...
Function n
<---
<---
<---
<---
<---
<---
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
...
IMAGE_THUNK_DATA

Now you should be able to understand what I mean. Don't be confused by the name IMAGE_THUNK_DATA: it's only an RVA into IMAGE_IMPORT_BY_NAME structure. If you replace the word IMAGE_THUNK_DATA with RVA in your mind, you'll perhaps see it more clearly. The number of array elements in OriginalFirstThunk and FirstThunk array depends on the functions the PE file imports from the DLL. For example, if the PE file imports 10 functions from kernel32.dll, Name1 in the IMAGE_IMPORT_DESCRIPTOR structure will contain the RVA of the string "kernel32.dll" and there will be 10 IMAGE_THUNK_DATAs in each array.
The next question is: why do we need two arrays that are exactly the same? To answer that question, we need to know that when the PE file is loaded into memory, the PE loader will look at the IMAGE_THUNK_DATAs and IMAGE_IMPORT_BY_NAMEs and determine the addresses of the import functions. Then it replaces the IMAGE_THUNK_DATAs in the array pointed to by FirstThunk with the real addresses of the functions. Thus when the PE file is ready to run, the above picture is changed to:

OriginalFirstThunk IMAGE_IMPORT_BY_NAME FirstThunk

|

|
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
IMAGE_THUNK_DATA
...
IMAGE_THUNK_DATA
--->
--->
--->
--->
--->
--->
Function 1
Function 2
Function 3
Function 4
...
Function n
Address of Function 1
Address of Function 2
Address of Function 3
Address of Function 4
...
Address of Function n

The array of RVAs pointed to by OriginalFirstThunk remains unchanged so that if the need arises to find the names of import functions, the PE loader can still find them.
There is a little twist on this *straightforward* scheme. Some functions are exported by ordinal only. It means you don't call the functions by their names: you call them by their positions. In this case, there will be no IMAGE_IMPORT_BY_NAME structure for that function in the caller's module. Instead, the IMAGE_THUNK_DATA for that function will contain the ordinal of the function in the low word and the most significant bit (MSB) of IMAGE_THUNK_DATA set to 1. For example, if a function is exported by ordinal only and its ordinal is 1234h, the IMAGE_THUNK_DATA for that function will be 80001234h. Microsoft provides a handy constant for testing the MSB of a dword, IMAGE_ORDINAL_FLAG32. It has the value of 80000000h.
Suppose that we want to list the names of ALL import functions of a PE file, we need to follow the steps below:

  1. Verify that the file is a valid PE
  2. From the DOS header, go to the PE header
  3. Obtain the address of the data directory in OptionalHeader
  4. Go to the 2nd member of the data directory. Extract the value of VirtualAddress
  5. Use that value to go to the first IMAGE_IMPORT_DESCRIPTOR structure
  6. Check the value of OriginalFirstThunk. If it's not zero, follow the RVA in OriginalFirstThunk to the RVA array. If OriginalFirstThunk is zero, use the value in FirstThunk instead. Some linkers generate PE files with 0 in OriginalFirstThunk. This is considered a bug. Just to be on the safe side, we check the value in OriginalFirstThunk first.
  7. For each member in the array, we check the value of the member against IMAGE_ORDINAL_FLAG32. If the most significant bit of the member is 1, then the function is exported by ordinal and we can extract the ordinal number from the low word of the member.
  8. If the most significant bit of the member is 0, use the value in the member as the RVA into the IMAGE_IMPORT_BY_NAME, skip Hint, and you're at the name of the function.
  9. Skip to the next array member, and retrieve the names until the end of the array is reached (it's null -terminated). Now we are done extracting the names of the functions imported from a DLL. We go to the next DLL.
  10. Skip to the next IMAGE_IMPORT_DESCRIPTOR and process it. Do that until the end of the array is reached (IMAGE_IMPORT_DESCRIPTOR array is terminated by a member with all zeroes in its fields).

Example:

This example opens a PE file and reads the names of all import functions of that file into an edit control. It also shows the values in the IMAGE_IMPORT_DESCRIPTOR structures.

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\comdlg32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\comdlg32.lib

IDD_MAINDLG equ 101
IDC_EDIT equ 1000
IDM_OPEN equ 40001
IDM_EXIT equ 40003

DlgProc proto :DWORD,:DWORD,:DWORD,:DWORD
ShowImportFunctions proto :DWORD
ShowTheFunctions proto :DWORD,:DWORD
AppendText proto :DWORD,:DWORD

SEH struct
PrevLink dd ? ; the address of the previous seh structure
CurrentHandler dd ? ; the address of the new exception handler
SafeOffset dd ? ; The offset where it's safe to continue execution
PrevEsp dd ? ; the old value in esp
PrevEbp dd ? ; The old value in ebp
SEH ends

.data
AppName db "PE tutorial no.6",0
ofn OPENFILENAME <>
FilterString db "Executable Files (*.exe, *.dll)",0,"*.exe;*.dll",0
             db "All Files",0,"*.*",0,0
FileOpenError db "Cannot open the file for reading",0
FileOpenMappingError db "Cannot open the file for memory mapping",0
FileMappingError db "Cannot map the file into memory",0
NotValidPE db "This file is not a valid PE",0
CRLF db 0Dh,0Ah,0
ImportDescriptor db 0Dh,0Ah,"================[ IMAGE_IMPORT_DESCRIPTOR ]=============",0
IDTemplate db "OriginalFirstThunk = %lX",0Dh,0Ah
           db "TimeDateStamp = %lX",0Dh,0Ah
           db "ForwarderChain = %lX",0Dh,0Ah
           db "Name = %s",0Dh,0Ah
           db "FirstThunk = %lX",0
NameHeader db 0Dh,0Ah,"Hint Function",0Dh,0Ah
           db "-----------------------------------------",0
NameTemplate db "%u %s",0
OrdinalTemplate db "%u (ord.)",0

.data?
buffer db 512 dup(?)
hFile dd ?
hMapping dd ?
pMapping dd ?
ValidPE dd ?

.code
start:
invoke GetModuleHandle,NULL
invoke DialogBoxParam, eax, IDD_MAINDLG,NULL,addr DlgProc, 0
invoke ExitProcess, 0

DlgProc proc hDlg:DWORD, uMsg:DWORD, wParam:DWORD, lParam:DWORD
.if uMsg==WM_INITDIALOG
  invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_SETLIMITTEXT,0,0
.elseif uMsg==WM_CLOSE
  invoke EndDialog,hDlg,0
.elseif uMsg==WM_COMMAND
  .if lParam==0
    mov eax,wParam
    .if ax==IDM_OPEN
      invoke ShowImportFunctions,hDlg
    .else ; IDM_EXIT
      invoke SendMessage,hDlg,WM_CLOSE,0,0
    .endif
  .endif
.else
  mov eax,FALSE
  ret
.endif
mov eax,TRUE
ret
DlgProc endp

SEHHandler proc C pExcept:DWORD, pFrame:DWORD, pContext:DWORD, pDispatch:DWORD
  mov edx,pFrame
  assume edx:ptr SEH
  mov eax,pContext
  assume eax:ptr CONTEXT
  push [edx].SafeOffset
  pop [eax].regEip
  push [edx].PrevEsp
  pop [eax].regEsp
  push [edx].PrevEbp
  pop [eax].regEbp
  mov ValidPE, FALSE
  mov eax,ExceptionContinueExecution
  ret
SEHHandler endp

ShowImportFunctions proc uses edi hDlg:DWORD
  LOCAL seh:SEH
  mov ofn.lStructSize,SIZEOF
  ofn mov ofn.lpstrFilter, OFFSET FilterString
  mov ofn.lpstrFile, OFFSET buffer
  mov ofn.nMaxFile,512
  mov ofn.Flags, OFN_FILEMUSTEXIST or OFN_PATHMUSTEXIST or OFN_LONGNAMES or OFN_EXPLORER or OFN_HIDEREADONLY
  invoke GetOpenFileName, ADDR ofn
  .if eax==TRUE
    invoke CreateFile, addr buffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
    .if eax!=INVALID_HANDLE_VALUE
      mov hFile, eax
      invoke CreateFileMapping, hFile, NULL, PAGE_READONLY,0,0,0
      .if eax!=NULL
        mov hMapping, eax
        invoke MapViewOfFile,hMapping,FILE_MAP_READ,0,0,0
        .if eax!=NULL
          mov pMapping,eax
          assume fs:nothing
          push fs:[0]
          pop seh.PrevLink
          mov seh.CurrentHandler,offset SEHHandler
          mov seh.SafeOffset,offset FinalExit
          lea eax,seh
          mov fs:[0], eax
          mov seh.PrevEsp,esp
          mov seh.PrevEbp,ebp
          mov edi, pMapping
          assume edi:ptr IMAGE_DOS_HEADER
          .if [edi].e_magic==IMAGE_DOS_SIGNATURE
            add edi, [edi].e_lfanew
            assume edi:ptr IMAGE_NT_HEADERS
            .if [edi].Signature==IMAGE_NT_SIGNATURE
              mov ValidPE, TRUE
            .else
              mov ValidPE, FALSE
            .endif
          .else
            mov ValidPE,FALSE
          .endif
FinalExit:
          push seh.PrevLink
          pop fs:[0]
          .if ValidPE==TRUE
            invoke ShowTheFunctions, hDlg, edi
          .else
            invoke MessageBox,0, addr NotValidPE, addr AppName, MB_OK+MB_ICONERROR
          .endif
          invoke UnmapViewOfFile, pMapping
      .else
          invoke MessageBox, 0, addr FileMappingError, addr AppName, MB_OK+MB_ICONERROR
      .endif
      invoke CloseHandle,hMapping
    .else
      invoke MessageBox, 0, addr FileOpenMappingError, addr AppName, MB_OK+MB_ICONERROR
    .endif
    invoke CloseHandle, hFile
   .else
   invoke MessageBox, 0, addr FileOpenError, addr AppName, MB_OK+MB_ICONERROR
   .endif
 .endif
 ret
ShowImportFunctions endp

AppendText proc hDlg:DWORD,pText:DWORD
   invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_REPLACESEL,0,pText
   invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_REPLACESEL,0,addr CRLF
   invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_SETSEL,-1,0
   ret
AppendText endp

RVAToOffset PROC uses edi esi edx ecx pFileMap:DWORD,RVA:DWORD
   mov esi,pFileMap
   assume esi:ptr IMAGE_DOS_HEADER
   add esi,[esi].e_lfanew
   assume esi:ptr IMAGE_NT_HEADERS
   mov edi,RVA ; edi == RVA
   mov edx,esi
   add edx,sizeof IMAGE_NT_HEADERS
   mov cx,[esi].FileHeader.NumberOfSections
   movzx ecx,cx
   assume edx:ptr IMAGE_SECTION_HEADER
   .while ecx>0 ; check all sections
     .if edi>=[edx].VirtualAddress
       mov eax,[edx].VirtualAddress
       add eax,[edx].SizeOfRawData
       .if edi<eax ; The address is in this section
         mov eax,[edx].VirtualAddress
         sub edi,eax
         mov eax,[edx].PointerToRawData
         add eax,edi ; eax == file offset
         ret
       .endif
     .endif
     add edx,sizeof IMAGE_SECTION_HEADER
     dec ecx
   .endw
   assume edx:nothing
   assume esi:nothing
   mov eax,edi
   ret
RVAToOffset endp

ShowTheFunctions proc uses esi ecx ebx hDlg:DWORD, pNTHdr:DWORD
   LOCAL temp[512]:BYTE
   invoke SetDlgItemText,hDlg,IDC_EDIT,0
   invoke AppendText,hDlg,addr buffer
   mov edi,pNTHdr
   assume edi:ptr IMAGE_NT_HEADERS
   mov edi, [edi].OptionalHeader.DataDirectory[sizeof IMAGE_DATA_DIRECTORY].VirtualAddress
   invoke RVAToOffset,pMapping,edi
   mov edi,eax
   add edi,pMapping
   assume edi:ptr IMAGE_IMPORT_DESCRIPTOR
   .while !([edi].OriginalFirstThunk==0 && [edi].TimeDateStamp==0 && [edi].ForwarderChain==0 && [edi].Name1==0 && [edi].FirstThunk==0)
     invoke AppendText,hDlg,addr ImportDescriptor
     invoke RVAToOffset,pMapping, [edi].Name1
     mov edx,eax
     add edx,pMapping
     invoke wsprintf, addr temp, addr IDTemplate, [edi].OriginalFirstThunk,[edi].TimeDateStamp,[edi].ForwarderChain,edx,[edi].FirstThunk      invoke AppendText,hDlg,addr temp
     .if [edi].OriginalFirstThunk==0
        mov esi,[edi].FirstThunk
     .else
        mov esi,[edi].OriginalFirstThunk
     .endif
     invoke RVAToOffset,pMapping,esi
     add eax,pMapping
     mov esi,eax
     invoke AppendText,hDlg,addr NameHeader
     .while dword ptr [esi]!=0
       test dword ptr [esi],IMAGE_ORDINAL_FLAG32
       jnz ImportByOrdinal
       invoke RVAToOffset,pMapping,dword ptr [esi]
       mov edx,eax
       add edx,pMapping
       assume edx:ptr IMAGE_IMPORT_BY_NAME
       mov cx, [edx].Hint
       movzx ecx,cx
       invoke wsprintf,addr temp,addr NameTemplate,ecx,addr [edx].Name1
       jmp ShowTheText
ImportByOrdinal:
       mov edx,dword ptr [esi]
       and edx,0FFFFh
       invoke wsprintf,addr temp,addr OrdinalTemplate,edx
ShowTheText:
       invoke AppendText,hDlg,addr temp
       add esi,4
    .endw
    add edi,sizeof IMAGE_IMPORT_DESCRIPTOR
  .endw
  ret
ShowTheFunctions endp
end start

Analysis:

The program shows an open file dialog box when the user clicks Open in the menu. It verifies that the file is a valid PE and then calls ShowTheFunctions.

ShowTheFunctions proc uses esi ecx ebx hDlg:DWORD, pNTHdr:DWORD
   LOCAL temp[512]:BYTE

Reserve 512 bytes of stack space for string operation.

   invoke SetDlgItemText,hDlg,IDC_EDIT,0

Clear the text in the edit control

   invoke AppendText,hDlg,addr buffer

Insert the name of the PE file into the edit control. AppendText just sends EM_REPLACESEL messages to append the text to the edit control. Note that it sends EM_SETSEL with wParam=-1 and lParam=0 to the edit control to move the cursor to the end of the text.

   mov edi,pNTHdr
   assume edi:ptr IMAGE_NT_HEADERS
   mov edi, [edi].OptionalHeader.DataDirectory[sizeof IMAGE_DATA_DIRECTORY].VirtualAddress

Obtain the RVA of the import symbols. edi at first points to the PE header. We use it to go to the 2nd member of the data directory array and obtain the value of VirtualAddress member.

   invoke RVAToOffset,pMapping,edi
   mov edi,eax
   add edi,pMapping

Here comes one of the pitfalls for newcomers to PE programming. Most of the addresses in the PE file are RVAs and RVAs are meaningful only when the PE file is loaded into memory by the PE loader. In our case, we do map the file into memory but not the way the PE loader does. Thus we cannot use those RVAs directly. Somehow we have to convert those RVAs into file offsets. I write RVAToOffset function just for this purpose. I won't analyze it in detail here. Suffice to say that it checks the submitted RVA against the starting-ending RVAs of all sections in the PE file and use the value in PointerToRawData field in the IMAGE_SECTION_HEADER structure to convert the RVA to file offset.
To use this function, you pass it two parameters: the pointer to the memory mapped file and the RVA you want to convert. It returns the file offset in eax. In the above snippet, we must add the pointer to the memory mapped file to the file offset to convert it to virtual address. Seems complicated, huh? :)

    assume edi:ptr IMAGE_IMPORT_DESCRIPTOR
.while !([edi].OriginalFirstThunk==0 &&
[edi].TimeDateStamp==0   && [edi].ForwarderChain==0 &&
[edi].Name1==0 && [edi].FirstThunk==0)

edi now points to the first IMAGE_IMPORT_DESCRIPTOR structure. We will walk the array until we find the structure with zeroes in all members which denotes the end of the array.

     invoke AppendText,hDlg,addr ImportDescriptor
     invoke RVAToOffset,pMapping, [edi].Name1
     mov edx,eax
     add edx,pMapping

We want to display the values of the current IMAGE_IMPORT_DESCRIPTOR structure in the edit control. Name1 is different from the other members since it contains the RVA to the name of the dll. Thus we must convert it to a virtual address first.

     invoke wsprintf, addr temp, addr IDTemplate, [edi].OriginalFirstThunk,[edi].TimeDateStamp,[edi].ForwarderChain,edx,[edi].FirstThunk      invoke AppendText,hDlg,addr temp

Display the values of the current IMAGE_IMPORT_DESCRIPTOR.

     .if [edi].OriginalFirstThunk==0
        mov esi,[edi].FirstThunk
     .else
        mov esi,[edi].OriginalFirstThunk
     .endif

Next we prepare to walk the IMAGE_THUNK_DATA array. Normally we would choose to use the array pointed to by OriginalFirstThunk. However, some linkers errornously put 0 in OriginalFirstThunk thus we must check first if the value of OriginalFirstThunk is zero. If it is, we use the array pointed to by FirstThunk instead.

     invoke RVAToOffset,pMapping,esi
     add eax,pMapping
     mov esi,eax

Again, the value in OriginalFirstThunk/FirstThunk is an RVA. We must convert it to virtual address.

     invoke AppendText,hDlg,addr NameHeader
     .while dword ptr [esi]!=0

Now we are ready to walk the array of IMAGE_THUNK_DATAs to look for the names of the functions imported from this DLL. We will walk the array until we find an entry which contains 0.

       test dword ptr [esi],IMAGE_ORDINAL_FLAG32
       jnz ImportByOrdinal

The first thing we do with the IMAGE_THUNK_DATA is to test it against IMAGE_ORDINAL_FLAG32. This test checks if the most significant bit of the IMAGE_THUNK_DATA is 1. If it is, the function is exported by ordinal so we have no need to process it further. We can extract its ordinal from the low word of the IMAGE_THUNK_DATA and go on with the next IMAGE_THUNK_DATA dword.

       invoke RVAToOffset,pMapping,dword ptr [esi]
       mov edx,eax
       add edx,pMapping
       assume edx:ptr IMAGE_IMPORT_BY_NAME

If the MSB of the IAMGE_THUNK_DATA is 0, it contains the RVA of IMAGE_IMPORT_BY_NAME structure. We need to convert it to virtual address first.

       mov cx, [edx].Hint
       movzx ecx,cx
       invoke wsprintf,addr temp,addr NameTemplate,ecx,addr [edx].Name1
       jmp ShowTheText

Hint is a word-sized field. We must convert it to a dword-sized value before submitting it to wsprintf. And we print both the hint and the function name in the edit control

ImportByOrdinal:
       mov edx,dword ptr [esi]
       and edx,0FFFFh
       invoke wsprintf,addr temp,addr OrdinalTemplate,edx

In the case the function is exported by ordinal only, we zero out the high word and display the ordinal.

ShowTheText:
       invoke AppendText,hDlg,addr temp
       add esi,4

After inserting the function name/ordinal into the edit control, we skip to the next IMAGE_THUNK_DATA.

    .endw
    add edi,sizeof IMAGE_IMPORT_DESCRIPTOR

When all IMAGE_THUNK_DATA dwords in the array are processed, we skip to the next IMAGE_IMPORT_DESCRIPTOR to process the import functions from other DLLs.

Appendix:

It would be incomplete if I don't mention something about bound import. In order to explain what it is, I need to digress a bit. When the PE loader loads a PE file into memory, it examines the import table and loads the required DLLs into the process address space. Then it walks the IMAGE_THUNK_DATA array much like we did and replaces the IMAGE_THUNK_DATAs with the real addresses of the import functions. This step takes time. If somehow the programmer can predict the addresses of the functions correctly, the PE loader doesn't have to fix the IMAGE_THUNK_DATAs each time the PE file is run. Bound import is the product of that idea.
To put it in simple terms, there is a utility named bind.exe that comes with Microsoft compilers such as Visual Studio that examines the import table of a PE file and replaces the IMAGE_THUNK_DATA dwords with the addresses of the import functions.When the file is loaded, the PE loader must check if the addresses are valid. If the DLL versions do not match the ones in the PE files or if the DLLs need to be relocated, the PE loader knows that the precomputed addresses are not valid thus it must walk the array pointed to by OriginalFirstThunk to calculate the new addresses of import functions.
Bound import doesn't have much significance in our example because we use OriginalFirstThunk by default. For more information about the bound import, I recommmend LUEVELSMEYER's pe.txt.

[Iczelion's Win32 Assembly Homepage]


Iczelion's PE Tutorial 7: Export Table

Tutorial 7: Export Table

We have learned about one part of the dynamic linking, namely the import table, in the previous tutorial. Now we will learn about the other side of the coin, the export table.

Download the example.

Theory:

When the PE loader runs a program, it loads the associated DLLs into the process address space. It then extracts information about the import functions from the main program. It uses the information to search the DLLs for the addresses of the functions to be patched into the main program. The place in the DLLs where the PE loader looks for the addresses of the functions is the export table.

When a DLL/EXE exports a function to be used by other DLL/EXE, it can do so in two ways: it can export the function by name or by ordinal only. Say if there is a function named "GetSysConfig" in a DLL, it can choose to tell the other DLLs/EXEs that if they want to call the function, they must specify it by its name, ie. GetSysConfig. The other way is to export by ordinal. What's an ordinal? An ordinal is a 16-bit number that uniquely identifies a function in a particular DLL. This number is unique only within the DLL it refers to. For example, in the above example, the DLL can choose to export the function by ordinal, say, 16. Then the other DLLs/EXEs which want to call this function must specify this number in GetProcAddress. This is called export by ordinal only.

Export by ordinal only is strongly discouraged because it can cause a maintenance problem for the DLL. If the DLL is upgraded/updated, the programmer of that DLL cannot alter the ordinals of the functions else other programs that depend on the DLL will break.

Now we can examine the export structure. As with import table, you can find where the export table is from looking at the data directory. In this case, the export table is the first member of the data directory. The export structure is called IMAGE_EXPORT_DIRECTORY. There are 11 members in the structure but only some of them are really used.

Field Name | Meaning
nName | The actual name of the module. This field is necessary because the name of the file can be changed. If it's the case, the PE loader will use this internal name.
nBase | A number that you must bias against the ordinals to get the indexes into the address-of-function array.
NumberOfFunctions | Total number of functions/symbols that are exported by this module.
NumberOfNames | Number of functions/symbols that are exported by name. This value is not the number of ALL functions/symbols in the module. For that number, you need to check NumberOfFunctions. This value can be 0. In that case, the module may export by ordinal only. If there is no function/symbol to be exported in the first case, the RVA of the export table in the data directory will be 0.
AddressOfFunctions | An RVA that points to an array of RVAs of the functions/symbols in the module. In short, RVAs to all functions in the module are kept in an array and this field points to the head of that array.
AddressOfNames | An RVA that points to an array of RVAs of the names of functions in the module.
AddressOfNameOrdinals | An RVA that points to a 16-bit array that contains the ordinals associated with the function names in the AddressOfNames array above.

Just reading the above table may not give you the real picture of the export table. The simplified explanation below will clarify the concept.

The export table exists for use by the PE loader. First of all, the module must keep the addresses of all exported functions somewhere so the PE loader can look them up. It keeps them in an array that is pointed to by the field AddressOfFunctions. The number of elements in the array is kept in NumberOfFunctions. Thus if the module exports 40 functions, it must have 40 members in the array pointed to by AddressOfFunctions and NumberOfFunctions must contain a value 40. Now if some functions are exported by names, the module must keep the names in the file. It keeps the RVAs to the names in an array so the PE loader can look them up. That array is pointed to by AddressOfNames and the number of names in NumberOfNames. Think about the job of the PE loader, it knows the names of the functions, it must somehow obtain the addresses of those functions. Up to now, the module has two arrays: the names and the addresses but there is no linkage between them. Thus we need something that relates the names of the functions to their addresses. The PE specification uses indexes into the address array as that essential linkage. Thus if the PE loader finds the name it looks for in the name array, it can obtain the index into the address table for that name too. The indexes are kept in another array (the last one) pointed to by the field AddressOfNameOrdinals. Since this array exists as the linkage between the names and the addresses, it must have exactly the same number of elements as the name array, ie. each name can have one and only one associated address. The reverse is not true: an address may have several names associated with it. Thus we can have "aliases" that refer to the same address. To make the linkage works, both name and index arrays must run in parallel, ie. the first element in the index array must hold the index for the first name and so on.

AddressOfNames AddressOfNameOrdinals
|
|
RVA of Name 1
RVA of Name 2
RVA of Name 3
RVA of Name 4
...
RVA of Name N
<-->
<-->
<-->
<-->
...
<-->
Index of Name 1
Index of Name 2
Index of Name 3
Index of Name 4
...
Index of Name N

An example or two is in order. If we have the name of an export function and we need to get its address in the module, we can do like this:

  1. Go to the PE header
  2. Read the virtual address of the export table in the data directory
  3. Go to the export table and obtain the number of names (NumberOfNames)
  4. Walk the arrays pointed to by AddressOfNames and AddressOfNameOrdinals in parallel, searching for the matching name. If the name is found in the AddressOfNames array, you must extract the value in the associated element in the AddressOfNameOrdinals array. For example, if you find the RVA of the matching name in 77th element of the AddressOfNames array, you must extract the value stored in the 77th element of the AddressOfNameOrdinals array. If you walk the array until NumberOfNames elements are examined, you know that the name is not in this module.
  5. Use the value from the AddressOfNameOrdinals array as the index into the AddressOfFunctions array. Say, if the value is 5, you must extract the value in the 5th element of the AddressOfFunctions array. That value is the RVA of the function.

Now we can turn our attention to the nBase member of the IMAGE_EXPORT_DIRECTORY structure. You already know that the AddressOfFunctions array contains the addresses of all export symbols in a module. And the PE loader uses the indexes into this array to find the addresses of the functions. Let's imagine the scenario where we use the indexes into this array as the ordinals. Since the programmers can specify the starting ordinal number in .def file, like 200, it means that there must be at least 200 elements in the AddressOfFunctions array. Furthermore the first 200 elements are not used but they must exist so that the PE loader can use the indexes to find the correct addresses. This is not good at all. The nBase member exists to solve this problem. If the programmer specifies the starting ordinal of 200, the value in nBase would be 200. When the PE loader reads the value in nBase, it knows that the first 200 elements do not exist and that it should subtract the ordinal by the value in nBase to obtain the true index into the AddressOfFunctions array. With the use of nBase, there is no need to provide 200 empty elements.

Note that nBase doesn't affect the values in the AddressOfNameOrdinals array. Despite the name "AddressOfNameOrdinals", this array contains the true indexes into the AddressOfFunctions array, not the ordinals.

With the discussion of nBase out of the way, we can continue to the next example.
Suppose that we have an ordinal of a function and we need to obtain the address of that function, we can do it like this:

  1. Go to the PE header
  2. Obtain the RVA of the export table from the data directory
  3. Go to the export table and obtain the value of nBase.
  4. Subtract the ordinal by the value in nBase and you have the index into the AddressOfFunctions array.
  5. Compare the index with the value in NumberOfFunctions. If the index is larger or equal to the value in NumberOfFunctions, the ordinal is invalid.
  6. Use the index to obtain the RVA of the function in the AddressOfFunctions array.

Note that obtaining the address of a function from an ordinal is much easier and faster than using the name of the function. There is no need to walk the AddressOfNames and AddressOfNameOrdinals arrays. The performance gain, however, must be balanced against the difficulty in the maintaining the module.

In conclusion, if you want to obtain the address of a function from its name, you need to walk both AddressOfNames and AddressOfNameOrdinals arrays to obtain the index into the AddressOfFunctions array. If you have the ordinal of the function, you can go directly to the AddressOfFunctions array after the ordinal is biased by nBase.

If a function is exported by name, you can use either its name or its ordinal in GetProcAddress. But what if the function is exported by ordinal only? We come to that now.
"A function is exported by ordinal only" means the function doesn't have entries in both AddressOfNames and AddressOfNameOrdinals arrays. Remember the two fields, NumberOfFunctions and NumberOfNames. The existence of these two fields is the evidence that some functions may not have names. The number of functions must be at least equal to the number of names. The functions that don't have names are exported by their ordinals only. For example, if there are 70 functions but only 40 entries in the AddressOfNames array, it means there are 30 functions in the module that are exported by their ordinals only. Now how can we find out which functions are exported by ordinals only? It's not easy. You must find that out by exclusion, ie. the entries in the AddressOfFunctions array that are not referenced by the AddressOfNameOrdinals array contain the RVAs of the functions that are exported by ordinals only.

Example:

This example is similar to the one in the previous tutorial. However, it displays the values of some members of IMAGE_EXPORT_DIRECTORY structure and also lists the RVAs, ordinals, and names of the exported functions. Note that this example doesn't list the functions that are exported by ordinals only.

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\comdlg32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\comdlg32.lib

IDD_MAINDLG equ 101
IDC_EDIT equ 1000
IDM_OPEN equ 40001
IDM_EXIT equ 40003

DlgProc proto :DWORD,:DWORD,:DWORD,:DWORD
ShowExportFunctions proto :DWORD
ShowTheFunctions proto :DWORD,:DWORD
AppendText proto :DWORD,:DWORD

SEH struct
   PrevLink dd ?
   CurrentHandler dd ?
   SafeOffset dd ?
   PrevEsp dd ?
   PrevEbp dd ?
SEH ends

.data
AppName db "PE tutorial no.7",0
ofn OPENFILENAME <>
FilterString db "Executable Files (*.exe, *.dll)",0,"*.exe;*.dll",0
             db "All Files",0,"*.*",0,0
FileOpenError db "Cannot open the file for reading",0
FileOpenMappingError db "Cannot open the file for memory mapping",0
FileMappingError db "Cannot map the file into memory",0
NotValidPE db "This file is not a valid PE",0
NoExportTable db "No export information in this file",0
CRLF db 0Dh,0Ah,0
ExportTable db 0Dh,0Ah,"======[ IMAGE_EXPORT_DIRECTORY ]======",0Dh,0Ah
            db "Name of the module: %s",0Dh,0Ah
            db "nBase: %lu",0Dh,0Ah
            db "NumberOfFunctions: %lu",0Dh,0Ah
            db "NumberOfNames: %lu",0Dh,0Ah
            db "AddressOfFunctions: %lX",0Dh,0Ah
            db "AddressOfNames: %lX",0Dh,0Ah
            db "AddressOfNameOrdinals: %lX",0Dh,0Ah,0
Header db "RVA Ord. Name",0Dh,0Ah
       db "----------------------------------------------",0
template db "%lX %u %s",0

.data?
buffer db 512 dup(?)
hFile dd ?
hMapping dd ?
pMapping dd ?
ValidPE dd ?

.code
start:
invoke GetModuleHandle,NULL
invoke DialogBoxParam, eax, IDD_MAINDLG,NULL,addr DlgProc, 0
invoke ExitProcess, 0

DlgProc proc hDlg:DWORD, uMsg:DWORD, wParam:DWORD, lParam:DWORD
.if uMsg==WM_INITDIALOG
   invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_SETLIMITTEXT,0,0
.elseif uMsg==WM_CLOSE
   invoke EndDialog,hDlg,0
.elseif uMsg==WM_COMMAND
   .if lParam==0
     mov eax,wParam
     .if ax==IDM_OPEN
       invoke ShowExportFunctions,hDlg
     .else ; IDM_EXIT
       invoke SendMessage,hDlg,WM_CLOSE,0,0
     .endif
   .endif
.else
   mov eax,FALSE
   ret
.endif
mov eax,TRUE
ret
DlgProc endp

SEHHandler proc C pExcept:DWORD, pFrame:DWORD, pContext:DWORD, pDispatch:DWORD
mov edx,pFrame
assume edx:ptr SEH
mov eax,pContext
assume eax:ptr CONTEXT
push [edx].SafeOffset
pop [eax].regEip
push [edx].PrevEsp
pop [eax].regEsp
push [edx].PrevEbp
pop [eax].regEbp
mov ValidPE, FALSE
mov eax,ExceptionContinueExecution
ret
SEHHandler endp

ShowExportFunctions proc uses edi hDlg:DWORD
LOCAL seh:SEH
mov ofn.lStructSize,SIZEOF ofn
mov ofn.lpstrFilter, OFFSET FilterString
mov ofn.lpstrFile, OFFSET buffer
mov ofn.nMaxFile,512
mov ofn.Flags, OFN_FILEMUSTEXIST or OFN_PATHMUSTEXIST or OFN_LONGNAMES or OFN_EXPLORER or OFN_HIDEREADONLY
invoke GetOpenFileName, ADDR ofn
.if eax==TRUE
   invoke CreateFile, addr buffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
   .if eax!=INVALID_HANDLE_VALUE
     mov hFile, eax
     invoke CreateFileMapping, hFile, NULL, PAGE_READONLY,0,0,0
     .if eax!=NULL
       mov hMapping, eax
       invoke MapViewOfFile,hMapping,FILE_MAP_READ,0,0,0
       .if eax!=NULL
         mov pMapping,eax
         assume fs:nothing
         push fs:[0]
         pop seh.PrevLink
         mov seh.CurrentHandler,offset SEHHandler
         mov seh.SafeOffset,offset FinalExit
         lea eax,seh
         mov fs:[0], eax
         mov seh.PrevEsp,esp
         mov seh.PrevEbp,ebp
         mov edi, pMapping
         assume edi:ptr IMAGE_DOS_HEADER
         .if [edi].e_magic==IMAGE_DOS_SIGNATURE
           add edi, [edi].e_lfanew
           assume edi:ptr IMAGE_NT_HEADERS
           .if [edi].Signature==IMAGE_NT_SIGNATURE
             mov ValidPE, TRUE
           .else
             mov ValidPE, FALSE
           .endif
         .else
           mov ValidPE,FALSE
         .endif
FinalExit:
         push seh.PrevLink
         pop fs:[0]
         .if ValidPE==TRUE
           invoke ShowTheFunctions, hDlg, edi
         .else
           invoke MessageBox,0, addr NotValidPE, addr AppName, MB_OK+MB_ICONERROR
         .endif
         invoke UnmapViewOfFile, pMapping
       .else
         invoke MessageBox, 0, addr FileMappingError, addr AppName, MB_OK+MB_ICONERROR
       .endif
       invoke CloseHandle,hMapping
     .else
       invoke MessageBox, 0, addr FileOpenMappingError, addr AppName, MB_OK+MB_ICONERROR
     .endif
     invoke CloseHandle, hFile
   .else
     invoke MessageBox, 0, addr FileOpenError, addr AppName, MB_OK+MB_ICONERROR
   .endif
.endif
ret
ShowExportFunctions endp

AppendText proc hDlg:DWORD,pText:DWORD
invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_REPLACESEL,0,pText
invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_REPLACESEL,0,addr CRLF
invoke SendDlgItemMessage,hDlg,IDC_EDIT,EM_SETSEL,-1,0
ret
AppendText endp

RVAToFileMap PROC uses edi esi edx ecx pFileMap:DWORD,RVA:DWORD
mov esi,pFileMap
assume esi:ptr IMAGE_DOS_HEADER
add esi,[esi].e_lfanew
assume esi:ptr IMAGE_NT_HEADERS
mov edi,RVA ; edi == RVA
mov edx,esi
add edx,sizeof IMAGE_NT_HEADERS
mov cx,[esi].FileHeader.NumberOfSections
movzx ecx,cx
assume edx:ptr IMAGE_SECTION_HEADER
.while ecx>0
   .if edi>=[edx].VirtualAddress
     mov eax,[edx].VirtualAddress
     add eax,[edx].SizeOfRawData
     .if edi<eax
       mov eax,[edx].VirtualAddress
       sub edi,eax
       mov eax,[edx].PointerToRawData
       add eax,edi
       add eax,pFileMap
       ret
     .endif
   .endif
   add edx,sizeof IMAGE_SECTION_HEADER
   dec ecx
.endw
assume edx:nothing
assume esi:nothing
mov eax,edi
ret
RVAToFileMap endp

ShowTheFunctions proc uses esi ecx ebx hDlg:DWORD, pNTHdr:DWORD
LOCAL temp[512]:BYTE
LOCAL NumberOfNames:DWORD
LOCAL Base:DWORD

mov edi,pNTHdr
assume edi:ptr IMAGE_NT_HEADERS
mov edi, [edi].OptionalHeader.DataDirectory.VirtualAddress
.if edi==0
  invoke MessageBox,0, addr NoExportTable,addr AppName,MB_OK+MB_ICONERROR
  ret
.endif
invoke SetDlgItemText,hDlg,IDC_EDIT,0
invoke AppendText,hDlg,addr buffer
invoke RVAToFileMap,pMapping,edi
mov edi,eax
assume edi:ptr IMAGE_EXPORT_DIRECTORY
mov eax,[edi].NumberOfFunctions
invoke RVAToFileMap, pMapping,[edi].nName
invoke wsprintf, addr temp,addr ExportTable, eax, [edi].nBase, [edi].NumberOfFunctions, [edi].NumberOfNames, [edi].AddressOfFunctions, [edi].AddressOfNames, [edi].AddressOfNameOrdinals
invoke AppendText,hDlg,addr temp
invoke AppendText,hDlg,addr Header
push [edi].NumberOfNames
pop NumberOfNames
push [edi].nBase
pop Base
invoke RVAToFileMap,pMapping,[edi].AddressOfNames
mov esi,eax
invoke RVAToFileMap,pMapping,[edi].AddressOfNameOrdinals
mov ebx,eax
invoke RVAToFileMap,pMapping,[edi].AddressOfFunctions
mov edi,eax
.while NumberOfNames>0
   invoke RVAToFileMap,pMapping,dword ptr [esi]
   mov dx,[ebx]
   movzx edx,dx
   mov ecx,edx
   shl edx,2
   add edx,edi
   add ecx,Base
   invoke wsprintf, addr temp,addr template,dword ptr [edx],ecx,eax
   invoke AppendText,hDlg,addr temp
   dec NumberOfNames
   add esi,4
   add ebx,2
.endw
ret
ShowTheFunctions endp
end start

Analysis:

mov edi,pNTHdr
assume edi:ptr IMAGE_NT_HEADERS
mov edi, [edi].OptionalHeader.DataDirectory.VirtualAddress
.if edi==0
  invoke MessageBox,0, addr NoExportTable,addr AppName,MB_OK+MB_ICONERROR
  ret
.endif

After the program verifies that the file is a valid PE, it goes to the data directory and obtains the virtual address of the export table. If the virtual address is zero, the file doesn't have any exported symbol.

mov eax,[edi].NumberOfFunctions
invoke RVAToFileMap, pMapping,[edi].nName
invoke wsprintf, addr temp,addr ExportTable, eax, [edi].nBase, [edi].NumberOfFunctions, [edi].NumberOfNames, [edi].AddressOfFunctions, [edi].AddressOfNames, [edi].AddressOfNameOrdinals
invoke AppendText,hDlg,addr temp

We display the important information in the IMAGE_EXPORT_DIRECTORY structure in the edit control.

push [edi].NumberOfNames
pop NumberOfNames
push [edi].nBase
pop Base

Since we want to enumerate all function names, we need to know how many names there are in the export table. nBase is used when we want to convert the indexes into the AddressOfFunctions array into ordinals.

invoke RVAToFileMap,pMapping,[edi].AddressOfNames
mov esi,eax
invoke RVAToFileMap,pMapping,[edi].AddressOfNameOrdinals
mov ebx,eax
invoke RVAToFileMap,pMapping,[edi].AddressOfFunctions
mov edi,eax

The addresses of the three arrays are stored in esi, ebx, and edi, ready to be accessed.

.while NumberOfNames>0

Continue until all names are processed.

   invoke RVAToFileMap,pMapping,dword ptr [esi]

Since esi points to an array of RVAs of the exported names, dereference it will give the RVA of the current name. We convert it to the virtual address, to be used in wsprintf later.

   mov dx,[ebx]
   movzx edx,dx
   mov ecx,edx
   add ecx,Base

ebx points to the array of ordinals. Its array elements are word-size. Thus we need to convert the value into a dword first. edx and ecx contain the index into the AddressOfFunctions array. We will use edx as the pointer into the AddressOfFunctions array. We add the value of nBase to ecx to obtain the ordinal number of the function.

   shl edx,2
   add edx,edi

We multiply the index by 4 (each element in the AddressOfFunctions array is 4 bytes in size) and then add the address of the AddressOfFunctions array to it. Thus edx points to the RVA of the function.

   invoke wsprintf, addr temp,addr template,dword ptr [edx],ecx,eax
   invoke AppendText,hDlg,addr temp

We display the RVA, ordinal, and the name of the function in the edit control.

   dec NumberOfNames
   add esi,4
   add ebx,2
.endw

Update the counter and the addresses of the current elements in AddressOfNames and AddressOfNameOrdinals arrays. Continue until all names are processed.

[Iczelion's Win32 Assembly Homepage]


ASM : Créer une dll - CodeS SourceS

Appeler une routine ASM à partir d'un prog en C (mode console)

Pour les débutants comme moi, voici comment utiliser un prog ASM dans un prog C et inversement en mode console.

----------------------------------------------------------------------------------------------------------------------

module C;

     #include <stdio.h>
     #include <stdlib.h>

     extern int asm_main

     int main()
     {
      int retour;
      retour=asm_main();
      printf("le resultat de la routine asm_main est : %ld",retour);
      return 0;
      }

module asm;

        .586
        .model small,c

        asm_main	PROTO C

        .code

        asm_main	PROC C
            mov eax,10
            mov ebx,20
            add eax,ebx
            ret
        asm_main	endp

        end

vous assembler le module asm,vous renommer en .o au lieu de .obj,et vous lier avec le module C.

Appeler une routine C dans un prog asm (mode console)
-----------------------------------------------------

Vous devez utiliser un module C comme "lanceur" du prog asm.
C'est cela qui permet d'utiliser les librairies C.

module C;

     #include <stdio.h>
     #include <stdlib.h>

     extern int asm_main

     int main()
     {
      int retour;
      retour=asm_main();
      return 0;
      }

module asm:

    .586
    .model small,c

    printf PROTO NEAR,string:DWORD,P1:DWORD
    asm_main	PROTO

    .data

    format	byte '%ld',13,0

    .code

    asm_main PROC PUBLIC uses ecx

        mov eax,30
        mov ecx,30
        add eax,ecx
        invoke printf,offset format,eax

        mov eax,0
        ret

    asm_main endp

    end

Pour tranformer les protypes des fonctions C en syntaxe MASM,il faut utiliser H2INC.exe (fournit avec masm 615 normallement)

Bonne prog.
parki

A voir également

  • Interface c et asm
  • Interface c et asm » Sites
  • Informe de la capaciter des disques durs(interface win32) » Codes sources - C / C++ / C++.NET (Fichiers / Disque)
  • Comment obtenir des infos sur votre processeur par l'instruction asm cpuid... » Codes sources - Visual Basic / VB.NET (API)
  • Création et modification de raccourcis windows (.lnk) avec interface ishelllink » Codes sources - Visual Basic / VB.NET (Shell)


FAIRE UNE ROUTINE EN ASM POUR DU C++ [MASM32,VC++] | Source N° 37

FAIRE UNE ROUTINE EN ASM POUR DU C++ [MASM32,VC++]
Catégorie | : | c++ et asm
Date | : | 04/08/2002
Auteur | : | PierreF [ 2 Sources ] [ Ecrire un message ]
Niveau | : | 1
Note moyenne | : | [ Note moyenne : Pas de Note pour le moment ]
Zip | : | Sources du Projet Fichier Source du Projet (vous devez être connecté pour récupérer le fichier)
N'EXECUTEZ PAS DE FICHIER EXE, DLL, OCX ETC... QUI POURRAIENT ÊTRE DANS LE FICHIER ZIP SANS AVOIR UN ANTI-VIRUS A JOUR DE LANCE SUR VOTRE MACHINE ! DE PREFERENCE OUVREZ LES FICHIERS SOURCES PLUTOT QU'UN EXE
SI VOUS ETES NOUVEAU ? ====> A LIRE AVANT TOUTE CHOSE !

une simple petite routine en ASM qui fait une addition (c'est pour l'exemple)
Utilise MASM32 et VC++
;******************************
;***    code assembleur     ***
;***        c_mod.asm       ***
;*** Utilise MASM32 et VC++ ***
;******************************

.386             ;il faut un proc 32 bits (VC++ c'est du 32 bits)
 .model FLAT,c    ; Le C est obligatoire.
.CODE
PUBLIC addition  ;addition est un fonction public

addition PROC    ;la fonction addition

                 ;Quand on crée un fonction en asm, il faut respecter un impératif:
                 ;ne pas modifier EBP (ou alors le sauvegarder)

                 ;Et bien sur il faut que les PUSH soit associer à des POP
                 ;(donc ESP doit êtres à la fin à la même valeur que au début)

                 ;quand un programme appelle un fonction il met sur la pile les arguments
                 ;(offset ou valeur selon que soit un pointeur ou pas)

                 ;ici VC++ met sur la pile les 2 valeurs (17 et 21), il met la dernière (20) puis le première (12)
                 ;REM: les 2 arguments sont des short(2 octet) mais VC++ met sur la pile 4 octets par argument
                 ;(donc 8 octets)
                 ;VC++ appelle notre fonction avec un CALL, donc est mit sur la pile les 4 octets de retour.
                 ;
                 ;Voila à quoi ressemble la pile aprés le CALL
          pointeur(ESP)
          |
  PILE    |OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|........
          |      |      |      |      |      |      |      |      |      |      |      |      |

            --- adresse de retour ---   --- 1er argument (17) ---   --- 2eme argument (21)---
          0                           4                           8
    PUSH EBP          ;ESP se déplace de 4 (ESP=ESP-8)
    MOV  EBP,ESP      ;
                      ;Voila à quoi ressemble la pile aprés le PUSH de EBP

          pointeur(ESP)
          |
  PILE    |OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|OCTECT|........
          |      |      |      |      |      |      |      |      |      |      |      |      |      |      |      |      |

           ------- PUSH de EBP ------   --- adresse de retour ---   --- 1er argument (17) ---   --- 2eme argument (21)---
          0                           4                           8                           12                          16

    MOV EAX,[EBP+8]   ;on passe par dessus EBP et l'adresse de retour, on a le 1er argument
    MOV EBX,[EBP+8+4] ;on passe par dessus EBP ,  l'adresse de retour et le 1er argument, on a le 2eme argument

        ADD EAX,EBX   ;l'addition

    MOV ESP,EBP       ;je sais pas trop à quoi ca sert, c'était dans le livre que j'ai utilisé pour savoir
                      ;comment faire les routine en ASM pour le C ou le basic
    POP EBP           ;on reprend EBP
    RET               ;Fin, la valeur de retour est dans EAX

 addition ENDP

END

   ***************************
   ***  Code en C++(ou C)  ***
   ***       main.cpp      ***
   ***************************

   #include <stdio.h>

   extern "C" unsigned short addition (unsigned short ,unsigned short );

   void main()
   {
     int somme;
     somme=addition(17,21);
     printf("12+20 (en ASM!)= %d\n",somme);
   }

Les commentaires ne sont pas disponibles dans la compil'. Vous pouvez les consulter sur le site ou sur le CD.
 Voir cette source "on-line" sur le site avec tous les commentaires et le reste

Ajoutez vos sources
(vous devez être connecté à internet)

<= Source Précedente -- Source suivant =>

Site Réalisé Par N.SOREL (Nix)
ASM Codes Sources
CodeS-SourceS.com© tous droits réservés


L'assembleur avec C++ Builder

Table des matières Vu dans http://glouise.developpez.com/assembleur

  • I. Petit rappel improvisé
  • II. Principe de l'assembleur
  • III. La mémoire
  • IV. Syntaxe d'accès avec C++Builder
  • V. Premier cas : mémoire déclarée dans la pile
  • VI. Deuxième cas : mémoire déclarée dans le tas
  • VII. Utilisation de l'assembleur sous DOS
  • VIII. Test sous C++Builder

Dans ce qui suit, nous nous limitons d'une part à C++ Builder pour PC et d'autre part à l'assembleur du 80386 de chez Intel. Pour utiliser cet assembleur, vous avez deux possibilités : soit insérer dans votre programme C/C++ des lignes d'assembleur, soit utiliser l'assembleur en tant que tel sous DOS via une "invite de commandes" et donc écrire un programme intégralement en assembleur. Nous abordons l'un et l'autre aspect de la question.

I. Petit rappel improvisé

C'est en 1974 que naît le premier microprocesseur de la série, le 8080. Son nom évoque probablement les années 80 à venir, lesquelles inaugurent l'explosion de l'informatique, tout comme son très proche cousin, le Z-80, surs ensemble du 8080 avec lequel il est full compatible.
Le microprocesseur 8080 est une pure merveille. Mais d'une part, c'était un microprocesseur 8 bits (cela signifie que son bus de lecture-écriture est de huit fils parallèles en conséquence de quoi on ne peut lire ou écrire en mémoire que huit bits à la fois soit un octet) et d'autre part il ne pouvait adresser que 64K0, ce qui s'est vite avéré insuffisant. Sa structure interne est d'une rare simplicité avec ses huit registres 8 bits A, B, C, D, E, H, L et M. Un registre est une sorte de variable, c'est un circuit qui se trouve à l'intérieur du microprocesseur (ce pourquoi on parle de "registre interne") et cette variable peut recevoir une valeur. Comme ces registres sont sur 8 bits, on peut leur donner une valeur comprise entre 0 et 255 i.e. en binaire entre 00000000 et 11111111. Le registre A est appelé "accumulateur" car il accumule les résultats, suite à une opération arithmétique, le résultat se trouve dans A. M est un faux registre, il s'agit du contenu pointé par HL où H signifie high et L low. H est donc l'octet haut d'adresse et L l'octet bas d'adresse, HL pointe donc une des 65536 cases mémoire numérotées (en décimal) de 0 à 65535 et M est l'octet pointé par HL. Par exemple l'instruction mov A,M signifie que le contenu pointé par HL est lu dans le registre A (l'accumulateur). Il est intéressant de remarquer la structure octalisante du 8080 avec des huit registres, ses huit types d'opérations (addition, addition avec carry, soustraction, soustraction avec carry, ET logique, OU logique, OU Exclusif logique et comparaison), ses huit types de sauts conditionnels en fonction de quatre indicateurs Z, C, S et P (zéro, carry, signe et parité). C'est pourquoi, la programmation en octal était très aisée, en une après-midi on connaissait pratiquement par cœur tous les codes octaux et on lisait l'assembleur directement en octal (base 8). Les deux premiers bits du code opératoire indiquent la nature de l'opération et les deux chiffres octaux suivants indiquent soit un type d'opération soit un registre impliqué dans l'opération. Ainsi si le code opératoire commence par "01", cela signifie "mov", ensuite viennent les deux registres impliqués. Les registres étaient indicés de 0 à 7 (BCDEHLMA). Par exemple mov A,B (le registre B est recopié dans A) s'écrit en octal 170 (soit 01111000 en binaire) car 7 signifie A et 0 signifie B. Inversement mov B,A s'écrit 107. Bref, le 8080 fut un microprocesseur minimal mais parfaitement efficace puisqu'on pouvait tout programmer avec. L'expérience montre qu'un jeu d'instructions réduit suffit largement à la programmation en assembleur, le 8080 en a donné la preuve avec élégance.
Vient ensuite le 8086. Deux grandes différences avec le 8080, d'une part c'est un microprocesseur 16 bits et d'autre part il pointe la mémoire par segments. La segmentation fut donc la grande différence avec le 8080. Avec le 8080, la mémoire était pointée directement par une valeur 16 bits alors qu'avec le 8086 on pointe la mémoire avec deux valeurs, un registre de segment et un offset c'est-à-dire une sorte d'indice ou de pointeur à l'intérieur du segment. Le registre de segment correspond aux 16 bits de poids fort d'une adresse 20 bits (en conséquence de quoi un segment pointe toujours une adresse divisible par 16) et l'offset une valeur 16 bits qui sert de pointeur dans le segment, l'addition de ces deux valeurs, la valeur 16 bits du segment auquel on adjoint quatre zéros à droite pour former une valeur 20 bits divisible par 16 et la valeur 16 bits de l'offset, l'addition de ces deux valeurs donc fournit l'adresse 20 bits invoquée. Le 8086 peut donc adresser 16 fois 64KO soit un MO (un méga octet). Il a quatre registres de segment, CS (code segment), DS (data segment), ES (extra segment) et SS (stack segment). Il a quatre registres généraux 16 bits, AX, BX, CX et DX (accumulateur, base, compteur et données) lesquels sont accessibles séparément en deux fois huit bits avec AH et AL pour AX (AH étant la partie haute de AX et AL sa partie basse donc AX=AH*256+AL), de même BH et BL pour BX, CH et CL pour CX, DH et DL pour DX. Par exemple l'instruction

MOV AX, 1027

qui signifie que le registre AX reçoit la valeur 1027, équivaut au couple d'instructions

MOV AH,4
MOV AL,3

puisque 4*256+3=1027.
Il a également deux registres d'index SI et DI (source index et destination index) et BP (base pointeur) utilisé dans certains modes d'adressage.
Ainsi, le 8086 ne pointe pas directement la mémoire. C'est toujours un couple de valeurs qui simulent une adresse 20 bits, par exemple DS:SI pointe l'adresse DS*16+SI. Puisque IP (instruction pointer) pointe par définition le code segment CS, le code opératoire qui va être lu est à l'adresse CS*16+IP. Par défaut, tous les modes d'adressage mémoire font intervenir le segment de données prévu à cet effet à savoir DS sauf les modes avec BP qui se calculent avec le registre de segment SS (stack segment). Par exemple l'instruction

MOV AL,[SI]

signifie que le contenu pointé par SI est lu dans le registre 8 bits AL. Mais le registre SI n'est que l'offset à l'intérieur d'un segment, le registre de segment impliqué est ici DS (data segment), l'adresse 20 bits lue sera donc DS*16+SI. Sinon, si on veut utiliser un autre registre de segment, il faut alors préfixer l'instruction et écrire par exemple

MOV AL,ES:[SI]

qui signifie qu'on ne calcule plus l'adresse via DS mais ES, l'octet lu dans AL est donc celui situé à l'adresse ES*16+SI. D'ailleurs le désassemblage donnerait

ES:
MOV AL,[SI]

ce qui montre clairement qu'on prévient ainsi le microprocesseur que le calcul de l'adresse se fera pour l'instruction suivante avec ES et non DS. Le quatre pointeurs (SI, DI, BX et BP) et huit modes d'adressage :

BX+SI+dep
BX+DI+dep
BP+SI+dep
BP+DI+dep
SI+dep
DI+dep
BP+dep
BX+dep

Toutes les syntaxes admettent un déplacement compris entre -32768 et +32767. En l'absence de préfixation, le registre de segment impliqué est DS sauf pour les trois modes où BP intervient.
Arrive enfin le 80386, le microprocesseur 32 bits. Sa structure est grosso modo identique à celle du 8086 mais tous les registres sont maintenant sur 32 bits et sont préfixés par la lettre E pour étendu (extended). On a donc les registres généraux EAX, EBX, ECX et EDX, les deux registres d'index ESI et EDI, le pointeur de base EBP. Puisque 32 bits d'adressage correspondent à 4GO, la segmentation n'est plus nécessaire mais les registres de segments sont maintenus pour des raisons de compatibilité ascendante. Pour plus d'informations sur le 80386 en tant que tel, je vous renvoie à d'autres informations.
On peut considérer le 80386 et ses successeurs comme des microprocesseurs bancals car il incluent la notion de segmentation simplement pour être compatibles avec leurs prédécesseurs alors qu'avec 32 fils d'adresse on accède à 4GO de mémoire vive, en conséquence de quoi la notion de segmentation est devenue totalement inutile.

II. Principe de l'assembleur

Le registre 32 bits EIP (instruction pointer) lit l'instruction qu'il pointe en mémoire vive. Le premier octet de chaque instruction est un code opératoire en fonction duquel le microprocesseur déduit les opérandes, il sait donc en fonction du code opératoire qu'il décode sur combien d'octets est codée l'instruction et la signification de ces octets. Puis le microprocesseur exécute cette instruction lue. Si un sous-programme est appelé par l'instruction CALL, l'adresse 32 bits pointée par EIP juste après le CALL qu'il vient de lire est sauvegardée dans la pile. La pile est un espace mémoire spécial où l'on peut sauvegarder des valeurs pour les récupérer ensuite. Quand on écrit par exemple

PUSH EAX

cela signifie que le registre 32 bits EAX est sauvegardé dans cet espace particulier, vous n'avez pas besoin de savoir où. Pour récupérer ensuite EAX on écrit simplement

POP EAX

Bien entendu c'est au programmeur à gérer ses PUSH et ses POP. Si vous sauvegardez EAX par PUSH EAX et que vous écriviez par la suite POP EBX, il est clair que vous récupérez dans EBX la valeur de EAX. En général, les PUSH correspondent aux POP en sens inverse, ils obéissent à la loi LIFO (last in, first out). Par exemple, imaginons une fonction qui va utiliser les registres EAX, EBX et ESI, on écrira

PUSH EAX
PUSH EBX
PUSH ESI

ici se trouve le corps de la fonction
utilisant EAX, EBX et ESI

POP ESI
POP EBX
POP EAX
RET

On voit donc que les POP s'effectuent dans l'ordre inverse des PUSH, la dernière valeur empilée étant ESI, c'est la première à être dépilée de manière à ce qu'elle soit bien lue dans ESI. L'intérêt d'une telle démarche est que le programme appelant n'a pas perdu le contenu de ses registres. Si par exemple EAX est égal à 2 avant cet appel, on aura bien EAX égal à 2 au retour de la fonction. Si toutefois votre fonction assembleur renvoie une valeur dans EAX que la fonction est censée calculer, il ne faut alors plus programmer le couple PUSH EAX/POP EAX sinon la valeur ne serait pas retournée. En C++ on se pose la question de savoir si on envoie un paramètre en tant que valeur ou en tant que référence via l'opérateur &, en assembleur on se pose la question de savoir si on doit ou non "pusher" les registres. Par défaut en C++, un paramètre est du type valeur (cela correspond au couple PUSH/POP en assembleur) sinon, si on utilise l'opérateur &, la valeur est retournée à l'appelant (ce qui équivaut à l'absence de PUSH/POP pour le registre concerné, son contenu est donc renvoyé à l'appelant).
Le registre EIP pointe toujours juste après l'instruction que le microprocesseur va exécuter. Si cette instruction est un CALL, EIP pointe précisément l'adresse de retour, la valeur de EIP est donc sauvegardée en pile (comme si finalement on écrivait PUSH EIP). Puis EIP pointe le début de la fonction puisqu'un CALL correspond aussi à un saut à une adresse, un saut correspondant à une affectation de EIP. L'instruction CALL FONCTION où FONCTION est l'adresse où débute une fonction correspond donc à PUSH EIP et à LEA EIP, FONCTION (mais ces instructions n'existent pas, c'est uniquement pour vous donner une correspondance). Quand le microprocesseur rencontre l'instruction RET, il suppose qu'il y a en pile l'adresse de retour (c'est au programmeur à faire en sorte qu'il en soit ainsi), il lit donc cette adresse dans EIP qui pointe donc, si la programmation est correcte, l'adresse sauvegardée c'est-à-dire juste après le CALL. On comprend donc que l'instruction RET équivaudrait à l'instruction moins parlante POP EIP qui n'existe pas.
Bien entendu, c'est à vous de gérer correctement la pile. Imaginons que dans l'exemple précédent, nous ayons oublié de programmer le POP EAX final juste avant le RET. Que va-t-il se passer? Le microprocesseur continue sa route, il décode l'instruction RET, il charge donc dans EIP l'adresse qu'il suppose être l'adresse de retour qu'il dépile mais comme il s'agit de EAX oublié, EIP va pointé à l'adresse EAX c'est-à-dire n'importe où en mémoire où le programme se plantera inévitablement.
Un des principes de base de l'assembleur est donc la gestion correcte de la pile, en gros, sauf astuce grossière et rarissime, autant de PUSH que de POP, autant de CALL que de RET. Cela dit, dans la programmation Windows, cette règle n'est plus vraie, il est fréquent de mettre en pile via PUSH les arguments d'une fonction Windows puis de l'appeler par CALL, la fonction "sait" combien d'arguments se trouvent en pile, elle les lit puis c'est elle qui se charge de les dépiler, on voit donc dans un programme assembleur Windows régulièrement une série de PUSH suivie d'un CALL à la fonction Windows mais sans les POP qui deviendraient fautifs puisque c'est la fonction elle-même qui a régularisé la pile.
Le principe général de l'assembleur est très simple : à chaque instruction exécutée, le microprocesseur positionne des flags en fonction du résultat de l'opération.
Ces flags sont à disposition du programmeur qui peut ou non les tester. Flag signifie "drapeau" en anglais et un drapeau "indique" quelque chose, le drapeau vert au bord de la mer "indique" qu'il est autorisé de se baigner, le drapeau d'une pendule d'échecs indique si le joueur est "tombé" ou non c'est-à-dire s'il a ou non dépassé le temps de réflexion. Les flags sont donc des indicateurs qui indiquent la façon dont la dernière opération s'est déroulée. Les deux flags les plus importants sont ZF et CF, "zéro flag" et "carry flag". On teste un flag en programmant un saut conditionnel en fonction de la position de ce flag. Si la condition testée est réalisée, le saut a lieu (EIP change de valeur, il pointe l'adresse de saut et le programme continue là) sinon, si la condition n'est pas réalisée, EIP ne saute pas et donc le programme continue comme si de rien n'était (puisque rien n'est). Imaginons que l'on veuille savoir si le registre AL est nul ou non, on écrira

TEST AL,AL
JZ ALNUL // saute à l'adresse ALNUL si ZF=1
ici le saut n'a pas eu lieu donc AL n'est pas nul

ALNUL:
ici le saut a eu lieu donc AL est nul

D'une manière générale, il faut considérer que les flags répondent à une question. Ainsi le flag ZF (zéro flag) répond à la question : le résultat de la dernière opération est-il nul? ZF=1 oui, ZF=0 non. JZ signifie "saute à l'adresse indiquée si Z c'est-à-dire si ZF=1", JNZ signifie "saute à l'adresse indiquée si Non Z c'est-à-dire si ZF=0".
Le flag CF (carry flag) répond à la question : le résultat de la dernière opération a-t-il provoqué un dépassement de capacité? CF=1 oui, CF=0 non. On appelle "dépassement de capacité" le fait que le résultat de l'opération ne peut pas tenir dans le registre qui reçoit le résultat. Imaginons l'instruction

add al,6

Cette instruction signifie qu'on ajoute 6 au registre 8 bits AL. Si le résultat "tient" sur 8 bits, on aura CF=0 mais si on dépasse le maximum autorisé à savoir 255 puisqu'on est sur 8 bits, on aura CF=1 et le résultat 8 bits ne sera plus le résultat réel mais le résultat modulo 256. On en conclut aisément que CF est dans tous les cas le bit 8 de l'opération (le neuvième bit), lequel bien sûr est à 0 s'il n'y a pas de dépassement et à 1 s'il y a dépassement, il s'agit tout simplement de la retenue binaire de l'opération. Si CF=0 après une opération 8 bits, cela signifie que le résultat est correct tel quel mais si CF=1 on n'a alors que le résultat modulo 256. De même suite à une opération 16 bits (par exemple add ax,6), CF représentera le bit 16 de l'opération (le dix septième bit) et suite à une opération 32 bits (par exemple add eax,6), CF représentera le bit 32 de l'opération (le trente troisième bit). À noter que, suite à un ADD, si ZF=1, on a alors obligatoirement CF=1 aussi car si la résultat est nul, il y a forcément eu dépassement de capacité. JC signifie "saute à l'adresse indiquée si CF=1", JNC signifie "saute à l'adresse indiquée si CF=0". En réalité ZF traite de l'égalité ou de l'inégalité alors que CF traite de la supériorité ou de l'infériorité. Par exemple pour savoir si ax est égal à bx on écrira

cmp ax,bx

La question que pose cette instruction est : ax=bx? et c'est l'indicateur ZF qui y répond, ZF=1 oui, ZF=0 non.
Si l'on veut savoir si bx est strictement inférieur à ax, on écrira la même instruction à savoir

cmp ax,bx

mais on testera cette fois-ci CF qui répond à la question : ax<bx? CF=1 oui, CF=0 non (ou bien sûr la question associée inverse équivalente bx>ax?). Ceci se comprend aisément car la comparaison exécute la soustraction virtuelle ax-bx. Or, le maximum que l'on peut soustraire à ax est ax lui-même mais au-delà, il y aura un dépassement de capacité. C'est pourquoi, ces deux indicateurs couvrent à eux seuls 99% des besoins, on ne trouve dans les listings que les sauts JZ/JNZ/JC/JNC et bien sûr le saut inconditionnel JMP. Les autres indicateurs sont très rarement testés.
Bien entendu, c'est au programmeur à être cohérent dans sa programmation. Si vous programmez un saut en fonction de Z suite à une instruction qui ne positionne pas Z, le saut aura lieu ou non en fonction de l'état de Z à ce moment-là, le microprocesseur ne s'occupe pas de savoir si vous avez précédemment positionné de façon cohérente l'indicateur testé. C'est pourquoi il ne suffit pas de connaître le jeu d'instructions, mais il faut pour chaque type d'instruction connaître le comportement des indicateurs. D'une manière générale, voici ce qu'il faut à peu près savoir.
Les instructions d'affectation du type MOV, PUSH, POP, LEA (load effective adresse), XCHG (swap de deux registres), XLAT (chargement dans AL de l'octet pointé par BX+AL), les manipulation de chaînes (REP MOVSB, REP MOVSW, REP MOVSD, qui recopient ECX contenus mémoire de ESI source vers EDI destination), les initialisations mémoire (REP STOSB, REP STOSW, REP STOSD qui recopient ECX fois respectivement AL, AX ou EAX à partir de EDI) etc. ne positionnent aucun indicateur. C'est d'ailleurs assez pratique car on peut insérer ce type d'instructions avant un saut conditionnel puisque ces chargements ne modifient pas les flags. De même les sauts conditionnels ou non et les appels qui ne sont autres que des chargements divers et variés de EIP.
Les incrémentations (INC) et décrémentations (DEC) positionnent tous les indicateurs sauf CF. On épargne ici CF qui reste inchangé. D'ailleurs, si ZF=1 après une incrémentation, le résultat est nul et il y a eu dépassement de capacité, ZF eût donc fait double emploi avec CF suite à une incrémentation, ce pourquoi il a été épargné.
Les opérations arithmétiques, addition (ADD), addition avec CF (ADC, cela signifie qu'on ajoute en plus l'indicateur CF, ceci revient à incrémenter le résultat si CF=1, ADC équivaut à ADD si CF=0), soustraction (SUB), soustraction avec carry (SBB, on soustrait en plus CF), comparaison (CMP) positionnent tous les indicateurs.
Les instructions logiques, ET logique (AND), OU logique (OR), OU exclusif (XOR) positionnent tous les indicateurs et remettent CF à 0. C'est très pratique, s'il y a eu une instruction logique, on sait qu'on a CF=0, c'est très fréquemment utile. À noter l'instruction TEST qui est un ET logique non destructif. Quand vous écrivez AND BH,DH, vous faites un ET logique bit à bit entre les deux registres 8 bits BH et DH et le résultat de ce ET logique se trouve après exécution dans BH mais quand vous faites TEST BH,DH, le résultat n'est transféré nulle part, cette instruction ne fait que positionner les indicateurs en fonction du résultat d'ailleurs perdu. TEST est donc un ET logique virtuel de même que CMP est une soustraction virtuelle, le résultat est perdu mais on a positionné les indicateurs en fonction de ce résultat, si donc ZF=1 après une comparaison, cela signifie que le résultat de la soustraction eût été nul, en conséquence de quoi les deux opérandes comparées sont égales. À noter l'instruction XOR AL,AL qui est un Ou exclusif entre AL et lui-même, c'est une petite astuce pour remettre AL à 0 (ou bien sûr AX ou EAX car ces syntaxes sont extensibles, on peut écrire XOR AX,AX ou XOR EAX,EAX). Imaginons maintenant qu'on veuille savoir la position du bit 3 et AL, on écrira TEST AL, 00001000b, si ZF=1 après exécution de cette instruction alors le résultat du ET logique aurait été nul en conséquence de quoi le bit 3 testé est nul donc au zéro logique et si ZF=0 alors le résultat du ET logique n'aurait pas été nul en conséquence de quoi le bit 3 est au 1 logique, le bit testé est donc l'inverse de ZF, il est à 1 si ZF=0 et à 0 si ZF=1. Imaginons qu'on veuille positionner au 1 logique les bits 2 et 10 de BX, on écrira OR BX, 0000010000000100b. Imaginons qu'on veuille annuler le bit 8 de EDX, on écrira AND EDX, 11111111111111111111111011111111b ou encore, si l'on veut éviter ce type d'écriture binaire AND EDX, 0FFFFFEFFh(dans la notation assembleur, on doit faire précéder les valeurs hexadécimales par 0 lorsque celles-ci commencent par une lettre pour éviter la confusion possible avec un label). Imaginons qu'on veuille inverser la valeur du bit 5 de CH, on écrira XOR CH,00100000b. En règle générale, on utilise le ET logique pour lire les bits ou les positionner au 0 logique, le OU logique pour positionner les bits au 1 logique et le OU exclusif pour inverser l'état logique des bits.
Les instructions de rotations et décalages, ROL et ROR (rotation circulaire à gauche et à droite, ROR rotation left, ROR rotation right), RCL et RCR (décalage avec CF entrant), SHL et SHR (décalage avec 0 entrant, SHL et SHR équivalent donc à RCL et RCR si CF=0, shift left et shift right) et enfin SAR (décalage à droite avec réinjection du bit de signe, shift arithmétique right) ne positionnent que CF qui représente donc le bit sortant du décalage. À noter qu'il n'y a que 7 types de rotations et décalages (et non 8) car SAR n'a pas sa réplique à gauche (le très gentil tasm32 accepte cependant l'instruction SAL mais le convertit en SHL sans autre forme de procès). En effet, s'il est signifiant de réinjecter le bit de signe i.e. le bit le plus à gauche sur un décalage à droite, il n'est pas signifiant de réinjecter le bit 0 sur un décalage à gauche. SAR permet de diviser par deux en maintenant le signe tel quel, si donc la valeur était négative (en considérant le complément à 2), elle restera négative après SAR car le bit de signe a été réinjecté. À noter que s'agissant des rotations et décalages, on a le choix entre l'exécuter une seule fois (e.g. ROR AL,1) ou CL fois (e.g. ROR AL,CL), dans ce cas bien sûr il faut renseigner CL par un mov juste avant par exemple MOV CL,3, ce qui aura pour effet de faire exécuter trois fois le décalage ou la rotation.
En résumé, les instructions
d'affection ne positionnent aucun indicateur
d'incrémentation positionnent tous les indicateurs sauf CF
arithmétiques positionnent tous les indicateurs
logiques positionnent tous les indicateurs sauf CF qui est remis à 0
de rotations et décalages ne positionnent que CF.

III. La mémoire

La mémoire n'est jamais qu'une suite d'octets consécutifs. Le 8080 ne pouvait lire ou écrire que huit bits à la fois (byte), le 8086 pouvait lire ou écrire deux octets consécutifs (word), le 80386, lui, peut lire ou écrire jusqu'à quatre octets consécutifs (double word). Mais que la mémoire soit pointée par byte, word ou double word, elle reste une suite d'octets numérotés et ces numéros ou indices sont des adresses. Par conséquent, la règle est simple :
en assembleur, il n'y a que des adresses et des contenus.
Le plus important donc, après avoir compris la pile et les indicateurs (flags) en relation avec les différents types d'instruction, est de comprendre la mémoire. Et pour comprendre la mémoire, il faut savoir pointer une adresse et savoir lire et écrire à cette adresse, c'est tout. Tout le reste en découlera. De même en langage C, si P est un pointeur de type char*, *P est le contenu pointé par P et &P est l'adresse ou se trouve écrit le pointeur P. P est le contenu d'adresse &P et *P le contenu d'adresse P. On voit donc que P est à la fois un contenu et une adresse, ce qui se simulera en assembleur par le fait qu'un pointeur par exemple ESI soit lui-même écrit à une adresse A. L'adresse A équivaut à &P, si je lis le contenu 32 bits à cette adresse dans ESI, ESI équivaut à P qui pointe lui-même quelque part et si je lis l'octet pointé par ESI, cet octet lu correspond à *P.

IV. Syntaxe d'accès avec C++Builder

Il y a deux cas, le cas où la mémoire à pointer se trouve dans la pile et le cas où elle se trouve dans le tas (heap en anglais). C'est sur ce plan-là que les syntaxes pour pointer la mémoire diffèrent. Quand vous déclarez une zone mémoire char zone[50] à l'intérieur d'une fonction, cette zone se situe en pile mais quand vous déclarez un pointeur P de type char* et que vous allouiez pour P de la mémoire par new ou malloc, seul le pointeur déclaré (char* P;) se trouve en pile mais la mémoire accordée par le système se situe dans le tas. Dans le premier cas, on fera pointer par exemple ESI à l'adresse zone par lea esi, zone alors que dans le deuxième cas, il faut lire le contenu P dans ESI pour que ESI pointe la mémoire allouée par new ou malloc et on doit alors écrire mov esi, [P] (les crochets entourant P sont facultatifs, on voit que cette notation est un peu ambiguë car en réalité on lit dans esi quatre octets à partir de l'adresse &P ce qui fait que dans cette instruction assembleur P ne signifie pas P du C++ mais &P et esi équivaut alors après exécution au P du C++). ESI pointant correctement la mémoire (puisqu'il équivaut au P du C++), la suite du programme sera la même, simplement dans le premier cas ESI pointe une zone dans la pile et dans le deuxième il pointe une zone dans le tas.

V. Premier cas : mémoire déclarée dans la pile

Vérifions par un petit exemple. Entrez dans C++Builder, sauvez le projet vierge pour l'instant dans un répertoire de test en gardant unitxx et projectxx (où xx est un nombre sur deux chiffres, par exemple si vous en êtes à votre test numéro 14, sauvegardez le projet avec les noms unit14 et projet14). Commencez par rajouter au début de unitxx.cpp l'instruction #pragma inline, c'est cette instruction qui déclare qu'il y aura de l'assembleur dans le source cpp. Donc pour l'instant unitxx.cpp va ressembler à ceci.

#include <vcl.h>
#pragma hdrstop

#include "Unit14.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#pragma inline
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}

Nous allons vérifiez qu'on pointe parfaitement la mémoire en mettant un bouton sur Form1, en créant un gestionnaire d'événement OnClick associé à ce bouton (il suffit de double-cliquer sur le bouton après l'avoir déposé n'importe où sur Form1). À l'intérieur de ce gestionnaire nous allons déclarer une chaîne de caractères que l'on va initialiser avec un message quelconque, on va déclarer une autre zone de caractères que l'on ne va pas du tout initialiser puis en assembleur, nous allons recopier la chaîne initialisée dans la zone prévue à cet effet puis nous allons afficher dans un MessageBox le contenu de cette zone où s'est effectuée la recopie. On constatera alors que la chaîne a bien été recopiée puisque c'est la chaîne recopiée que MessageBox va afficher et ce sera pour nous la preuve qu'on pointe correctement la mémoire.

void __fastcall TForm1::Button1Click(TObject *Sender)
{
char Message[]="Ceci est un message, vive l'assembleur!";
char Zone[100];

_asm
{
          cld
          lea esi,Message
          lea edi,Zone
          mov ecx,40
          REP MOVSB
}

Application->MessageBox(Zone, "ok",MB_OK);

}

On déclare d'abord notre message puis une zone mémoire arbitrairement assez longue pour accueillir une recopie du message initialisé. Ensuite on déclare qu'on va maintenant écrire en assembleur avec la directive _asm (on peut aussi écrire asm tout court ou encore __asm avec deux underscores). L'instruction cld signifie "clear DF" c'est-à-dire "mets à zéro le flag DF", ce flag "direction flag" indique si la copie répétitive qui suit doit se faire par incrémentation ou décrémentation, à 0 ce sera par incrémentation et à 1 ce sera par décrémentation. C'est un flag particulier que l'utilisateur positionne et que le microprocesseur utilise. Ensuite on fait pointer esi sur Message (esi pointe donc le premier code ascii du message) puis edi pointe le premier octet de la zone où la recopie va se faire puis on met le compteur ecx à 40 car c'est le nombre de caractères incluant le zéro de fin de chaîne à recopier puis on se contente d'écrire REP MOVSB ce qui signifie de recopier par incrémentation (car nous avons mis DF à 0) et par byte (MOVSW serait une recopie par word et MOVSD par double word) la source pointée par ESI dans la destination pointée par EDI. Vous remarquez qu'on n'utilise pas du tout les registres de segment qui sont initialisés une fois pour toutes par le système, on ne s'en occupe donc pas du tout (alors qu'en 8086 il fallait impérativement initialiser DS, le data segment, pour pointer correctement la mémoire).
Bien entendu, dans ce tout premier essai il nous a fallu calculer à la main la longueur du message et nous avons trouvé 40 incluant le zéro de fin de chaîne. Nous allons améliorer cette première tentative en écrivant une petite routine assembleur qui va nous calculer la longueur du message. On va donner à cette routine l'adresse ESI qui pointera le début du message, cette routine renverra le nombre de caractères dans le registre ECX utilisé comme compteur.

_asm
{
LongECX:   push esi
           mov ecx,0
LongECX10: mov al,
           inc ecx
           inc esi
           test al,al
           jnz LongECX10
           pop esi
           ret
}

Cette routine est une fonction comme une autre donc vous l'insérez dans le source C/C++ où vous voulez entre deux fonctions C++. En entrant dans le sous-programme LongECX, ESI est censé pointer correctement la mémoire. Cela dit, on sauvegarde son adresse en pile, ainsi au retour, esi pointera toujours le début de la chaîne à recopier et ce, bien qu'il va bouger dans la routine elle-même. On initialise le compteur ECX à 0. Puis la boucle commence. On lit dans AL l'octet pointé par esi. À la place de mov AL, [esi] nous aurions pu écrire mov AL, byte ptr mais la précision byte ptr n'est pas utile ici puisque le compilateur sait bien que AL est sur 8 bits. On n'écrit donc byte ptr ou word ptr ou encore dword ptr que lorsque cette précision est nécessaire. Par exemple, si l'on veut écrire 0 à l'adresse ESI, il faudra préciser s'il s'agit de 0 sur 8 bits, 0 sur 16 bits ou 0 sur 32 bits et donc choisir entre mov byte ptr [esi],0ou mov word ptr ,0ou encore mov dword ptr ,0. L'octet étant lu dans AL, on incrémente le compteur ecx et le pointeur esi puis on teste al par l'instruction test al,al qui fait un ET logique entre al et lui-même et ce, à seule fin de positionner les flags car nous voulons savoir si l'octet lu est nul ou non. Cette instruction est strictement équivalente à and al,al ou même or al,al car le ET logique et le OU logique sont idempotents. Si l'octet lu dans AL n'est pas nul, on saute à l'adresse LongECX10 où l'on va lire encore la mémoire (mais esi a avancé d'une case entre temps donc on va lire l'octet suivant). Tant qu'on aura à ce stade ZF=0, le saut aura lieu. Quand ZF sera au 1 logique après le test, la boucle s'arrêtera et ce, parce que le saut n'aura plus lieu. En effet, le saut a lieu si NZ mais n'a pas lieu si Z. On restitue alors à esi sa position d'origine par pop esi puis on retourne à l'appelant par l'instruction ret avec ECX qui contient la longueur de la chaîne incluant le zéro de fin. On voit qu'ici une erreur de programmation aurait été d'écrire le couple PUSH ECX/POP ECX car alors le contenu de ECX ne serait pas retourné. La relation entre le C++ et l'assembleur est inversée au sens où rien en C++ correspond au PUSH/POP en assembleur (argument du type valeur) alors que l'opérateur & en C++ correspond à rien en assembleur (absence de PUSH/POP, argument du type référence). Dans ces conditions, la fonction de recopie précédente sera légèrement modifiée, notamment ECX étant calculé par la fonction LongECX, il n'a plus à être initialisé par programme. Donc après avoir donné l'adresse Message à esi par lea esi, Message on appelle la fonction LongECX par call LongECX, puis on positionne EDI mais comme ECX a été calculé par la routine LongECX, on supprime l'instruction qui lui donnait dans notre exemple précédent la valeur 40. Voici l'ensemble de l'unité cpp qui contient maintenant plus d'assembleur que de C++. Remarquez bien la place de la routine LongECX à savoir comme une fonction C/C++ entre deux fonctions.

#include <vcl.h>
#pragma hdrstop

#include "Unit14.h"
//-------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#pragma inline
TForm1 *Form1;
//-------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------
_asm
{
LongECX:       push esi
               mov ecx,0
LongECX10:     mov al,
               inc ecx
               inc esi
               test al,al
               jnz LongECX10
               pop esi
               ret
}
//-------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
char Message[]="Ceci est un message, vive l'assembleur!";
char Zone[100];

_asm
{
               cld
               lea esi,Message
               call LongECX
               lea edi,Zone
               REP MOVSB
}

Application->MessageBox(Zone, "ok",MB_OK);

}
//-------------------------------------------------------

Remarquez que l'assembleur commence juste après le constructeur de TForm1. En effet, C++Builder ne permet pas de commencer par des lignes d'assembleur, cela provoque une erreur à la compilation. Les premières directives asm se situent donc juste après Tform1::TForm1.

VI. Deuxième cas : mémoire déclarée dans le tas

Modifions le programme précédent. Nous allons déclarer notre message de la même façon mais nous allons déclarer un pointeur P de type char* puis nous allons allouer à ce pointeur une zone de 100 octets par new. Cette zone va alors se situer dans le tas. On ne va donc plus pointer la zone via l'instruction lea (load effective adresse) car lea signifie qu'on donne au pointeur l'adresse directement et cette adresse nous ne la connaissons pas mais nous savons qu'elle se situe à l'adresse &P donc on va écrire mov edi, [P](car &P du C++ correspond à P en assembleur, il en est ainsi dans la notation), ce qui signifie que les 32 bits situés à partir de l'adresse &P sont lus dans EDI, le microprocesseur va donc lire quatre contenus aux adresses consécutives &P, &P+1, &P+2 et &P+3, ce qui va faire quatre octets qu'il va donner au registre 32 bits edi (adresse de destination de la future recopie du message initialisé). Dans ces conditions, EDI pointe la mémoire allouée par new. La recopie s'effectue de la même façon.

void __fastcall TForm1::Button1Click(TObject *Sender)
{
char Message[]="Ceci est un message, vive l'assembleur!";
char *P;
P=new char[100];

_asm
{
               cld
               lea esi,Message
               call LongECX           //ECX=longueur de la chaîne
               mov edi, [P]
               REP MOVSB
}

Application->MessageBox(P, "ok",MB_OK);
delete P;
}

Vous voyez clairement le rapport entre l'assembleur et le C. Si j'écris par exemple lea edi, P, cela signifie que edi pointe en pile l'adresse où se trouve le pointeur P, edi est alors égal à &P, si j'écris comme dans le programme mov edi, [P] cela signifie que je lis le pointeur P (les crochets sont d'ailleurs facultatifs) donc EDI équivaut alors à P et alors byte ptr [EDI] équivaut à *P que ce soit en lecture ou en écriture. Pour résumer :

lea edi, P signifie edi=&P
mov edi, P signifie edi=P
mov [EDI], AL signifie *P=AL
mov al, [EDI] signifie AL=*P
inc edi signifie P++
dec edi signifie P--

Vous pouvez consulter le programme assembleur créé par C++Builder, il suffit de l'ouvrir, son nom est unitxx.asm. Pour faire du pas à pas en assembleur, positionnez votre curseur sur la première instruction assembleur push esi puis faites F4 (exécution jusqu'au curseur). Là, le programme s'exécute, cliquez sur le bouton, cela provoque l'arrêt du programme à l'endroit où vous avez positionné le curseur. Faites Alt v d c, vous obtenez la fenêtre CPU (Alt active le menu, v pour voir, d pour debug et c pour CPU) ou encore appuyez simultanément sur ctrl et Alt et faites c, la fenêtre CPU s'affiche. Le mieux est le mode mixte où l'on vous donne à la fois le C++ et l'assembleur, cliquez à droite dans la fenêtre où se trouve le code et sélectionnez l'option "mixte" si elle n'est pas activée, cela permet le double affichage C++/assembleur. Si vous vous êtes perdu suite à des scrolls pour consulter le code de la fenêtre assembleur, cliquez à droite et faites "allez à l'EIP en cours", vous vous retrouvez à l'instruction où l'on est arrêté. En haut à droite, vous avez les registres internes du microprocesseur, en bas à gauche une zone mémoire quelconque et en bas à droite la pile. Regardez la valeur de esp, le pointeur de pile, vous constatez que la fenêtre de pile vous affiche l'état de la pile, une petite flèche verte vous montre la position du pointeur de pile esp et en regard la dernière valeur empilée. Si vous voulez consulter de la mémoire, utilisez la fenêtre en bas à gauche prévue à cet effet, cliquez à droite et choisissez "aller à l'adresse". En général on veut consulter une adresse contenue dans un registre, donc on donne le nom de ce registre et on vous affiche le contenu de la mémoire à cet endroit. Mais vous pouvez aussi donner une adresse, dans ce cas n'oubliez pas d'entrer le préfixe "0x" de manière à donner une valeur en hexadécimal (sinon C++Builder considère que c'est du décimal).

VII. Utilisation de l'assembleur sous DOS

Nous allons maintenant essayer notre assembleur sous DOS via une "invite de commandes" et non plus sous C++Builder. Commençons par créer un répertoire asm à l'intérieur du répertoire CBuilder5. Vous pouvez créer ce répertoire sous Windows. Sinon, utilisez une "invite de commandes", allez sous le répertoire Cbuilder5. Par exemple sous Windows98, l'invite de commandes vous fait aller au répertoire Windows, le prompt est donc ceci :

C:\Windows>

On commence par descendre à la racine :

C:\Windows>cd ..

Le prompt devient alors :

C:\>

Puis on se rend alors au répertoire Cbuilder5 :

C:\>cd "program files"\borland\cbuilder5

Là on crée le répertoire asm :

C:\Program Files"\Borland\CBuilder5>mkdir asm

C'est dans ce répertoire que nous allons développer en assembleur. Ce répertoire étant créé, sortons de l'invite de commandes puis rentrons-y à nouveau. On se retrouve sous le répertoire Windows. Là créons un petit go.bat qui va nous faire aller directement au répertoire asm. Pour cela entrons sous Edit, le petit éditeur de texte du DOS (vous pouvez créer ce petit "point bat" sous Windows avec NotePad, le bloc-notes standard, ce sera la même chose). Donc entrons sous Edit :

C:>\Windows>edit go.bat

L'éditeur s'ouvre et vous donne la main, entrez simplement la ligne :

cd ..\"program files"\borland\cbuilder5\asm

puis sauvez le document, faites Alt (pour activer le menu) puis f (pour activer l'option "fichier") puis e (pour enregistrer) puis de nouveau Alt puis f puis q pour quitter.
Vous êtes de nouveau sous le répertoire Windows, il ne vous reste plus qu'à entrer la commande go pour exécuter ce go.bat qu'on vient d'écrire.

C:>\Windows>go

On se rend ainsi à notre répertoire asm plus facilement. Le prompt est donc (maintenant que nous sommes "chez nous") :

C:>\Program Files\Borland\CBuilder5\asm>

Là nous créons un petit c.bat pour compiler et lier c'est-à-dire créer l'exécutable exe à partir d'un fichier assembleur asm. Donc on entre sous Edit :

C:>\Program Files\Borland\CBuilder5\asm>edit c.bat

Là, vous êtes sous éditeur de texte, entrez ces deux lignes :

tasm32 -ml prg
ilink32 -x -c prg ,,,..\lib\import32

puis sauvez ce document, faites Alt (pour activer le menu) puis f (pour activer l'option "fichier") puis e (pour enregistrer) puis de nouveau Alt puis f puis q pour quitter. Il suffit d'apprendre une fois pour toutes cette série de six touches pour sauvegarder un document sous Edit : Alt f e Alt f q.
On suppose là que notre programme va s'appeler prg.asm. Attention à la syntaxe, les espaces sont importants ainsi que le nombre de virgules. Comme vous le voyez, l'assembleur s'appelle tasm32 (turbo assembleur 32 bits) et le lieur ilink32 (incremental link 32 bits). Pour connaître les options de l'assembleur et du lieur, il suffit d'entrer leur nom sous DOS, la commande tasm32 vous donnera donc toutes les options de l'assembleur et la commande ilink32 toutes les options du lieur. Remarquez aussi que nous faisons le lien avec la librairie import32, ce qui nous permettra d'accéder aux fonctions Windows. Nous sommes prêts pour écrire notre premier petit programme en assembleur. Vous pouvez également remplacer prg par %1 qui représente le premier argument qui sera donné à la commande c (il faut donc faire deux fois ce remplacement car prg apparaît deux fois), dans ce cas on ne compilera pas par c tout court mais par c suivi du nom du programme par exemple c prg. Entrons maintenant sous Edit et créons le programme prg.asm.

C:>\Program Files\Borland\CBuilder5\asm>edit prg.asm

Là, entrez le programme suivant ou mieux, comme c'est un peu long, faites un copier-coller sous Windows avec NotePad, le résultat sera le même, sauvegardez ce fichier sous le nom prg.asm.

.386
locals
jumps
.model flat,STDCALL

extern MessageBoxA : Proc

.data
titre           db "In girum imus nocte et consumimur igni",0
texte           db "Bienvenue dans les tutoriaux",10,10
                db "Vive l'assembleur!",0

.code
Programme:
                push 0                  ; type de fenêtre
                push offset titre
                push offset texte
                push 0
                call MessageBoxA
                ret                      ; retour sous DOS
End Programme

Vous reconnaissez le "data segment" annoncé par .data à l'intérieur duquel nous avons créé des chaînes de caractères via la directive db (define byte), le "code segment" annoncé par .code, là où se trouve le programme. Il est important de commencer par un libellé, ici Programme, et de terminer par End suivi de ce même nom donc End Programme. Ce programme est très court car il s'agit d'un essai. On sauvegarde en pile le type de fenêtre voulu (ici 0 qui correspond à une fenêtre simple avec le bouton OK, correspondant à MB_OK) puis l'adresse "titre" (où se trouve le titre de la fenêtre, chaîne de caractères terminée par zéro), puis l'adresse "texte" puis enfin 0 (zéro, indication supplémentaire utilisée par le système). Puis on appelle MessageBoxA (qui se trouve dans import32, la librairie standard avec laquelle nous avons lié le programme dans notre c.bat) puis on termine par l'instruction ret, retour au programme appelant donc retour sous DOS.
Il ne reste plus qu'à compiler et lier ce programme pour en obtenir l'exécutable donc on entre simplement la commande c qui va exécuter notre petit c.bat créé précédemment.

C:>\Program Files\Borland\CBuilder5\asm>c

Le programme se compile sans erreur. On l'exécute maintenant en entrant son nom, donc :

C:>\Program Files\Borland\CBuilder5\asm>prg

Une fenêtre Windows s'affiche avec le bouton OK.
Vous constatez qu'ici nous n'avons pas programmé les POP alors qu'il y a quatre PUSH, cela est dû à la syntaxe d'appel des fonctions Windows, les arguments se situent dans la pile avant l'appel. Comme la fonction le "sait", c'est elle qui se charge de dépiler ces valeurs de manière à ce que la pile soit régularisée au retour. Si vous voulez un listing de votre programme avec les codes hexadécimaux, rajouter l'option -l à la commande tasm32 c'est-à-dire écrivez dans le c.bat la ligne

tasm32 -ml -l prg

C'est la même ligne que précédemment mais on a rajouté l'option -l. Dans ces conditions, notre commande c de création de l'exécutable fournira en plus le fichier prg.lst qui est le listing complet du programme totalement construit et très bien présenté, à consulter via NotePad sous Windows ou via Edit sous DOS.

VIII. Test sous C++Builder

Maintenant, si vous voulez tester le programme assembleur DOS précédent sous C++Builder pour faire du pas à pas, ce n'est pas immédiat, il faut alors quelque peu modifier la présentation du programme précédent pour lui donner une écorce C++ car il est en assembleur pur. Créez sous Windows un nouveau répertoire de travail. C'est une précaution importante car nous allons modifier ce programme en le faisant devenir un programme C++ avec la directive _asm. Or, dans ces conditions, C++Builder crée lui-même un asm suite à la compilation et donc écraserait le prg.asm d'origine si l'on travaillait dans le même répertoire (ou alors il faudrait changer le nom du programme mais un répertoire nouveau est préférable pour ne pas mélanger l'assembleur avec le C++).
Le même programme que précédemment pourrait se présenter de la façon suivante :

#pragma inline
void main(void)
{
_asm
{
Programme:
                push 0
                push offset titre
                push offset texte
                push 0
                call MessageBoxA
                jmp fin

titre           db "In girum imus nocte et consumimur igni",0
texte           db "Bienvenue dans les tutoriaux",10,10
                db "Vive l''assembleur!",0

extern MessageBoxA : Proc

fin:
}
}

On commence par #pragma inline pour indiquer au compilateur C++ qu'il y aura de l'assembleur. On crée le programme maître void main(void){} et à l'intérieur des parenthèses on crée la directive _asm{}, on recopie le programme mais on remplace ret par jmp fin, on crée le label fin juste avant la parenthèse fermante de la directive asm, on recopie les chaînes de caractères mais on rajoute une quote au message "vive l''assembleur" (une double quote n'en vaut qu'une en assembleur), on déclare la fonction externe MessageBoxA, on supprime "End Programme" qui ne vaut qu'en assembleur pur. Ce fichier étant au point, sauvez-le dans le répertoire nouveau précédemment créé sous le nom prg.cpp. Puis faites "Fichier|Nouveau" et choisissez "Expert console", là donnez dans la fenêtre le nom du programme prg.cpp avec le chemin correct et cochez la case "Spécifiez le source du projet". Puis faites "Fichier|Enregistrer le projet sous" et donnez un nom à ce projet (laissez par exemple Projet1 proposé) car même un simple programme console doit avoir un nom de projet associé en C++Builder. Maintenant, vous pouvez exécutez le programme et donc aussi l'exécuter au pas à pas en mode debug avec la fenêtre CPU.


Vu dans ... http://luce.yves.pagesperso-orange.fr/Masm_C++.htm

MASM et C++

Le c,c++,traduit en assembleur avec l'option FA, peuvent répondre à beaucoup de questions en matière de code,de calculs,d'optimisation.Cest pourquoi editmasm vous permet de créer des projets c ou c++.Ces ambitions restent modestes,il vous fera gagner un temps précieux à la compilation sur de courts exemples en c,c++.

Il vous permet,en particulier,d'utiliser les nombreux bouts de code fournis par MSDN.

Le windows.sdk permet d'utiliser la bibliotèque de fonctions c++ sans se poser beaucoup de questions.Il vous faut le c++ express téléchargeable gratuitement.Quelques exemples viendront illustrer içi la traduction des deux langages.Les fonctions de la bibliothèque sont fort bien expliquées içi avec des exemples.

Editmasm permet d'utiliser cl en ligne de commande.Avantage,l'aide est disponible même si vous n'avez pas visual studio.La version express du c++ ne la fournit pas .

Principales différences:

L'assembleur travaille avec des registres eax,ecx,.. le VC++ avec des noms définis par l'utilisateur

L'assembleur connait offset,addr,lea, [registre] pour définir une adresse,sinon on a affaire a une valeur.

Seul les déclarations utilisateur du c++ permettent de définir une adresse ou une valeur.

invoke mafonction,valeur,addr adresse ;l'absence de addr identifie valeur comme une valeur

en c++ on doit lire les déclarations pour savoir si on utilise une adresse ou valeur.

RECT rcCurrent = {0,0,20,20},*LPrcCurrent; on définit un pointeur sur rcCurrent

LPrcCurrent dd offset rcCurrent ;en assembleur

OffsetRect(LPrcCurrent, rc.right / 2, rc.bottom / 2);

Si on suprime le *LPrcCurrent,il faut écrire:

OffsetRect(&rcCurrent, rc.right / 2, rc.bottom / 2);

Les déclarations du c++ sont nombreuses et très pointilleuses

retour = SendMessage(hToolTip, TTM_ADDTOOL, 0, &toolInfo)

On veut passer l'adresse de la structure toolInfo a la fonction et on obtient le message:

d:\vc++\tooltip\tooltip\tooltip.cpp(222): error C2664: 'SendMessageA' : impossible de convertir le paramètre 4 de 'TTTOOLINFOA *' en 'LPARAM'

Aucun contexte dans lequel cette conversion est possible

En général,içi on s'arrache un peu la tête.Le c++ est un macro langage,c'est une macro qui remplit les registres nécessaires a l'éxécution du code.Dans ce cas,il faut rajouter des précisions pour que la macro puisse traduire.

On rajoute (LPARAM)(LPTOOLINFO) et la macro comprend que l'on veut placer un * TOOLINFO,pointeur sur TOOLINFO dans un LPARAM = * PARAM ,un pointeur sur PARAM.La macro voit l'équivalence entre deux pointeurs et tout va mieux.

retour = SendMessage(hToolTip, TTM_ADDTOOL, 0,(LPARAM)(LPTOOLINFO) &toolInfo)

le reinterpret_cast:

hbrush = CreatePatternBrush(hbm);
hbrushOld = SelectObject(hdc, hbrush);

d:\vc++\brush\brush.cpp(386): error C2440: '=' : impossible de convertir de 'HGDIOBJ' en 'HBRUSH'
La conversion de 'void*' en pointeur vers non 'void' nécessite un cast explicite

ce sont deux dword,il ne devrait pas y avoir de probleme,le tout est de savoir comment.

On regarde le proto:

__gdi_entry WINGDIAPI HGDIOBJ WINAPI SelectObject(__in HDC hdc, __in HGDIOBJ h);

si on ecrit:

hbrushOld = (HBRUSH)SelectObject(hdc, hbrush);

on demande au vc++ de reinterpréter l'appel,et ça passe

METHODE de RECHERCHE: Internet tapez c++ HBRUSH HGDIOBJ dans google

-------------------- pointilleuse syntaxe --------------------------------------------------------------------

BOOL CALLBACK BrosseDlgProc( HWND , UINT, WPARAM , LPARAM)

n'est pas

BOOL CALLBACK BrosseDlgProc( HWND , UINT, LONG ,LONG)

parce qu'une procédure dialog est défini ainsi:

typedef INT_PTR (CALLBACK* DLGPROC)(HWND, UINT, WPARAM, LPARAM);

Si on utilise la deuxieme forme,les erreurs deviennent fort peu clairs.

write

C exemple de conversion

#include <io.h>

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <string.h>

#define FILENAME "write.dat"

int main(void)

{

int fh;

char buffer[20];

memset(buffer, 'a', 20); /* initialize storage */

printf("\nCreating " FILENAME ".\n");

system("echo Sample Program > " FILENAME);

if (-1 == (fh = open(FILENAME, O_RDWR|O_APPEND))) {

perror("Unable to open " FILENAME);

return EXIT_FAILURE;

}

if (5 != write(fh, buffer, 5)) {

perror("Unable to write to " FILENAME);

close(fh);

return EXIT_FAILURE;

}

printf("Successfully appended 5 characters.\n");

close(fh);

return 0;

/****************************************************************************

The program should create a file "write.dat" containing:

Sample Program

aaaaa

The output should be:

Creating write.dat.

Successfully appended 5 characters.

****************************************************************************/

TRADUCTION MASM

;link /SUBSYSTEM:CONSOLE

.586

.model flat, stdcall

option casemap :none ; case sensitive

main PROTO C

include \masm32\sdk\translate.inc ;le seul fichier ajouté

include \masm32\sdk\io.sdk

include \masm32\sdk\stdio.sdk

include \masm32\sdk\stdlib.sdk

include \masm32\sdk\fcntl.sdk

include \masm32\sdk\string.sdk

includelib \PROGRA~1\MICROS~1.0\VC\lib\libcmt.lib ;msvcrt.lib

includelib \PROGRA~1\MICROS~1.0\VC\lib\OLDNAMES.lib

; #########################################################################

.const

FILENAME equ "write.dat"

.data

sortie db FILENAME,0

message db 13,10,"Creating ", FILENAME,13,10,0

commande db "echo Sample Program > ", FILENAME,0

meserroropen db "Unable to open to ",FILENAME,0

meserrorwrite db "Unable to write to ",FILENAME,0

messuccess db "Successfully appended 5 characters.",13,10,0

;testé les erreurs RAJOUT

badfile db "machin.dat",0

.code

main PROC C

LOCAL fh:DWORD

LOCAL buffer[20]:BYTE

;remplir buffer avec des a

invoke memset,addr buffer, "a", sizeof buffer ; /* initialize storage */

invoke printf,addr message

invoke system,addr commande

invoke _open,addr sortie,O_RDWR or O_APPEND

mov fh,eax

.if eax == -1 ;INVALID_HANDLE_VALUE

invoke perror,addr meserroropen

mov eax, EXIT_FAILURE

ret

.endif

invoke _write,fh,addr buffer, 5

.if eax != 5

invoke perror,addr meserrorwrite

invoke close,fh

mov eax, EXIT_FAILURE

ret

.endif

invoke printf,addr messuccess

invoke _close,fh

mov eax,0

ret

main endp

Fonctions ayant un nom incompatible avec Masm

Certaines fonctions C sont des noms réservés dans masm,exemple dup.Pour masm,elle signifie une longueur de variable,pour le C c'est une fonction (un proc) de duplication.Il y a deux solutions pour résoudre le problème:

1)Se connecter dynamiquement à la fonction:

;déclarations

Pcrt_fabs TYPEDEF PROTO C :QWORD

Fcrt_fabs TYPEDEF PTR Pcrt_fabs

crt_fabs TEXTEQU <Fcrt_fabs ptr Acrt_fabs>

.data

Acrt_fabs dd 0

Il faut charger la dll contenant la fonction (loadlibrary ntdll.dll)

Utiliser getprocadress et mettre la valeur retourné dans Acrt_fabs

La fonction pourra être accédé par le nom,crt_fabs (invoke crt_fabs,value)

Les prototypes incompatibles sont mis en commentaire dans le windows.sdk

dup est deprecated,utiliser _dup

Pour d'autres fonctions,remplacé crt_fabs par l'autre nom de fonction dans toutes les déclarations

2)Utilisé la librairie masm_msvcrt:

Cette librairie fabriquée avec lib porte le nom de msvcrt.lib.Toutes les fonctions sont renommées

D'autres librairies windows,directx... utilisent les fonctions de cette librairie et cela pose de nombreux problèmes si on l'utilise.

Msvcrt et Libcmt

Les deux librairies contiennent les mêmes fonctions.

La msvcrt produit des éxécutables plus petit ( 50 Ko) mais demande le plus souvent,un manifeste

;dans le .rc

#define RT_MANIFEST 24

#define APP_MANIFEST 1

APP_MANIFEST RT_MANIFEST DISCARDABLE "Microsoft.VC80.CRT.manifest"

Le manifeste se trouve dans

C:\Program Files\Microsoft Visual Studio 9.0\VC\redist

La libcmt n'a pas besoin de manifeste et présente moins de problèmes a l'initialisation.

Sous-titre 4

Texte

Sous-titre 5

Texte

Sous-titre 6

Texte


Vu dans .... http://luce.yves.pagesperso-orange.fr/perso.htm

MASM librairies

Autres Sujets

Mettre a jour les librairies masm32
Utiliser les DLL
Pourquoi utiliser Statiquement ou dynamiquement les dll ?

Créer une librairie a partir de ses définitions de prototypes
 Utiliser le C++ et MASM

MASM32 fournit les moyens de se constituer une librairie personnelle.Cela permet d'intégrer facilement dans n'importe quel programme ses propres routines les plus souvent utilisées.En cas de debuggage de ces mêmes routines,il suffit alors de recompiler les programmes qui les utilisent.Inconvénient: les fonctions doivent être documentées avec la même rigueur que winhelp , prendre winhelp comme modèle.

La marche a suivre est la suivante:

créer un répertoire (c:\masm32\persolib)

placer make.bat dans ce répertoire

;----------------------------------- début fichier make.bat----------------------------------------------------------

;----------------------------------- fin de fichier make.bat ----------------------------------------------------------

L'instruction "pause" n'est pas optionnel.Windows fonctionnant en multitache,multithread , commence par éxécuter le link puis passe à la suppression des fichiers objets.La suppression est beaucoup plus rapide que link,le résultat est que la librairie produite est vide.L'éxécution asynchrone des fichiers batchs ressemble a un bug windows.

Former le Code du fichier Objet

Insérer un PROC dans le fichier suivant

    ;------------------------------------------------Squelette de création de l'objet----------------------

    ; #########################################################################

    .386 ; force 32 bit code

    .model flat, stdcall ; memory model & calling convention

    option casemap :none ; case sensitive

    ; --------------------------------

    ; Les fichiers inclus içi ,suprimer les points virgules:NE déclarer AUCUNE LIBRAIRIE

    ;c'est au programme utilisateur de rajouter les .lib nécessaires.

    ; --------------------------------

    include \masm32\include\windows.inc

    include \masm32\include\lz32.inc

    include \masm32\include\user32.inc

    include \masm32\include\kernel32.inc

    ; include \masm32\include\masm32.inc

    ; include macros.txt

    ; ---------------------------------------------------------

    ; Les PROTO sont tous regroupés dans un fichier .inc du même

    ; nom que la librairie .lib

    ; ---------------------------------------------------------

    ;lorsque un proc en utilise un autre,syntaxe externdef nom : définition

    ; EXTERNDEF LongZtexte:PROTO :DWORD,:DWORD

    ; EXTERNDEF EtatMemoirePile :MEMORY_BASIC_INFORMATION

    ; EXTERNDEF PoriginePile:DWORD

    .data ;les données placées içi ne seront reconnus que par cette routine

    .code

    ;################################################################

    ;insérer le PROC içi

    ;################################################################

    end ;et non pas end start,signe le fichier librairie

    ;---------------------------- fin de fichier ----------------------------------------------

assembler chaque proc séparément pour vérifier son fonctionnement
Procéder de même pour chaque PROC

Lancer MAKE, fini !

          Documenter la fonction en utilisant le HTML Help Wokshop

Mise à jour des librairies de MASM32

Trois utilitaires permettent de gérer les problèmes liés aux librairies

inc2l,malgré quelques défauts,extrait la librairie d'une dll lorsqu'on lui fournit un fichier inclus comportant les déclarations de PROTO des fonctions fournis par la DLL.Voir MSDN pour écrire les nouveaux protos,on peut se servir de l'ancien .inc pour éviter de tout réécrire.Les nouvelles définitions de protos doivent être exacts et comporter la taille des arguments passés a l'appel de la fonction.On ne peut pas se simplifier le travail en ne mettant que le nom de la fonction.Mettre l'inclus dans un répertoire et appeler inc2l en lui passant le nom de l'inclus

l2inca: Extrait les protos d'une librairie,mieux vaut utiliser protolib (editmasm)

l2incu:même chose que l2inca mais pour la convention UNICODE ,fonctions se terminant par W

LIB:création de la librairie a partir des fichiers objets

Utilisation statique et dynamique des DLL (adresses des API fixes ou recherchées)

De manière statique:

    On rajoute les déclarations de proto et la librairie aux sources

    include \MASM32\include\dbghelp.inc

    includelib \masm32\lib\dbghelp.lib

    Utilisation des fonctions

invoke SymSetOptions,options

De manière dynamique: (voir la page outils)

    Aucun fichier a inclure au source

    Déclarations:

      zSymSetOptions TYPEDEF PROTO :DWORD

      fSymSetOptions TYPEDEF PTR zSymSetOptions

      SymSetOptions TEXTEQU <fSymSetOptions ptr HSymSetOptions>

    data

      HSymSetOptions dd 0

    Charger la dll

      invoke LoadLibrary,SADD("dbghelp.dll")

    Obtenir l'adresse de la fonction

    invoke GetProcAddress,hLib,SADD("SymSetOptions")

    mov HSymSetOptions,eax

    Utilisation des fonctions

    invoke SymSetOptions,options

Mises A jour des librairies Windows:

Utilisation Statique:(adresse des APIS fixes)

Lorsque microsoft modifie les dll,les librairies sont elles aussi modifiées.Les adresses des fonctions APIS changent et ..... les programmes utilisant les vieilles librairies ne marchent plus.Il est nécessaire alors de recompiler avec les nouveaux inclus et les nouvelles librairies.

Utilisation Dynamique:

Plus de problèmes.L'adresse étant recherché dans la dll,celle ci peut avoir changée , cela n'a pas d'importance.

Microsoft fait attention au problème et recommande l'utilisation dynamique lorsque les APIS sont en cours de dévellopement et sont susceptibles de changer

Exemples:

dbghelp.dll , la dll des debugging tools change tous les six mois,utiliser la de manière dynamique

DirectX est en constante évolution , a utiliser dynamiquement

Les fonctions serveurs 2003 sont elles aussi susceptibles d'être modifiés,a utiliser dynamiquement de préfèrence

Kernel32.dll est a la base de tous les programmes,on peut utiliser le mode statique.

Exemple d'utilisation dynamique

Un exemple un peu poussé puisqu'il n'utilise que le chargement dynamique.C'est editmasm qui a créé les nombreuses déclarations nécessaires à l'aide des déclarations de protos contenus dans masm32

Bricolage:

Comment créer une librairie a partir d'une dll

Recréer les librairies

deux méthodes

Avec DUMPBIN et LIB /DEF:

1) dumpbin /EXPORTS nom.dll > nom.txt ,extrait le nom des fonctions exportés par la dll

2) créer le fichier def (celui servant a définir les fonctions exportés

lorsque l'on crée une dll)

LIBRARY nom

EXPORTS

;suite des noms repris de nom.txt

3) créer la librairie

lib /DEF:nom.def

La librairie créer ne peut être appeler que par un call

Créer le code d'une librairie sans code,ne contenant que l'appel

    ;----------------------------------------------------------

    .386

    .model flat,stdcall

    .code

    fonction1 proc param1:DWORD, param2:DWORD ...

    fonction1 endp

    ........2 et ainsi de suite

    end

    ;----------------------------------------------------------

    c'est le code d'une librairie,pas de "start: end start"

    créer le point def comme précédemment

    compiler

    ml /c /coff /Cp nom.asm

    link /DLL /NOENTRY /def:nom.def /subsystem:windows nom.obj

    on obtient une lib invokable, une dll vide de code,a effacer

Utiliser polib

C:\masm32\tools\INC2L\INC2L.EXE efface la dll

Le principe de fonctionnement est expliqué au dessus

Une librairie kernel a jour est nécessaire pour utiliser les exceptions avec editmasm
Préférez les librairies fournies par microsoft,quelques problèmes existent en les recréant.

On peut avoir des librairies a jour avec le SDK

Utiliser le C++ et MASM ,résoudre les problèmes d'incompatibilité avec d'autres systèmes

On peut utiliser des librairies C++ dans des programmes MASM.

Libcmt.lib vous oblige à modifier la structure habituelle de MASM et a utiliser un mot réservé

.code

start:

---- içi code--

end start

devient

.code

WinMain proc STDCALL public uses esi edi ebx,hInst:DWORD,hPrev:DWORD,\
lpCmdLine:DWORD,nShowCmd:SDWORD

WinMain endp
end

WinMain est le mot réservé pour désigner le point d'entrée du code (au lieu de start:,changeable).Le fichier crt0.c donne les mots réservés à utiliser en fonction du programme.Celui ci se trouve en C:\Program Files\Microsoft SDK\src\crt.

msvcrt.lib vous oblige à utiliser un manifest.Un fichier manifest est un fichier texte,modifiable avec notepad,dont le format d'écriture est le XML.

Manifest:

Un fichier manifest est identifié comme tel par le système,lorsqu'il possède l'extension .manifest.Il sert a aiguiller le système dans l'utilisation de tel ou tel librairie.Il joue un rôle particulier lorsqu'on utilise CRT,MFC et ATL.Il indique au système ou trouver les librairies Mt.exe est le tool permettant de les manipuler (SDK et C++).Le cas général,sans problème particulier,est résolu par celui-ci:

Il doit être présent dans le fichier ressource pour être opérationnel

#define RT_MANIFEST 24

#define APP_MANIFEST 1

APP_MANIFEST RT_MANIFEST DISCARDABLE "libs.manifest" //"Microsoft.VC80.CRT.manifest"

Au cas ou un programme doit utiliser une ancienne version de dll,le fichier manifest sert à déclarer la dépendance du programme vis à vis de ces DLL.Exemple le Microsoft.VC80.CRT.manifest.les librairies dépendantes doivent se trouver dans le même répertoire que le programme

Un fichier manifest peut aussi servir à déclarer l'utilisation des XP THEMES,common controls

Si vous avez deux .manifest à incorporer (un seul est possible) utiliser mt.exe pour les réunir.


D:\COM_CHM\Documentation CHM\_ASM\ASM__DOC\Tasm\ASMCHAP5.rtf

CHAPITRE 5 - Assembleur & C

L'inclusion de modules en assembleur dans les programmes de haut niveau constitue un objectif fondamental de la programmation en assembleur. Si les langages de haut niveau présentent beaucoup d'avantages et sont plus agréables à manier que l'assembleur, il leur arrive de ne pas connaître certaines fonctions indispensable à un projet. Également, pour le traitement des boucles interne (inner loops), il est carrément impératif d'utiliser l'assembleur. Il existe 3 façon d’inclure de l’assembleur dans nos sources C. On peut avoir recours à l’assembleur interne du compilateur, utiliser un assembleur externe directement dans notre source ou à l’extérieur de celui-ci.

Utilisation du compilateur interne

Tous les compilateurs modernes ont un assembleur interne qui permet d’inclure directement dans du code source des lignes de codes assembleur. En Borland C++, il s’agit de l’instruction asm. Nous avons déjà vu sont utilisation, comme par exemple :

void mode_graphique()
{
asm {
MOV AX, 0x13
INT 0x10
}
}

L’assembleur interne est cependant beaucoup moins efficace qu’un assembleur externe tel MASM ou TASM. Je n’expliquerai pas ici en détails tous les routines traduites en assembleur, car à présent vous devriez être capable de suivre le déroulement d’une fonction assembleur à partir du code source. J’ai néanmoins commenté le code pour vous aider dans cette tâche.

Inclure des routines de bas niveau dans le C

Ce processus s'effectue en 2 étapes: premièrement, il faut coder les fonctions elles-mêmes dans un fichier source ASM. Ensuite, il faut que le compilateur C puisse y référer. Cependant, il faudra légèrement modifier notre code asm pour que nos fonctions soient à même d'être adressées et encore plus important, qu'elles puissent recevoir des paramètres.

Tous les langages de haut niveau ont une exigence commune vis-à-vis du module en assembleur: ils réclament l'installation d'un cadre de pile. Il s'agit en fait d'un dédoublement du segment de pile dans le registre BP. Comme la pile du langage de haut niveau de doit pas être modifier, le contenu du pointeur de pile est copié en BP. Avant cela, l'ancienne valeur de BP est sauvegardée sur la pile. Donc, tous modules assembleurs destinés à être incorporé dans du code de haut niveau doit commencer par les instructions:
PUSH BP
MOV BP,SP

Également, chaques fonctions doit être déclarée PUBLIC, c'est à dire la rendre accessible à tous les modules du projet. Pour restaurer la pile à son état original, il ne faut pas oublier l'évidence:

POP BP

Le nom de notre fonction dans le module assembleur devra être précédé du caractère de soulignement, _ ("underscore"). La commande ARG nous permet de spécifier les paramètres que notre fonction recevra. Par exemple, notre fonction pour choisir un mode vidéo par le BIOS deviendrait, si on veut l'utiliser avec un module externe, la suivante:

PUBLIC _setmode ; Utilisable par tous les modules

_setmode PROC ; PROCédure setmode (avec le _)
ARG mode:WORD ; Paramètre "mode"
PUSH BP ; sauvegarde bp
MOV BP,SP ; sur la pile
MOV AX, mode ; ax = mode
INT 10h ; interruption vidéo
POP BP ; on ramène la pile originale
RET ; toujours mettre RET
_setmode ENDP ; fin de la procédure

Modifications dans notre code C

Pour compiler correctement notre code dans l'environnement C, il faudra créer un fichier project. Pour ce faire, dans le menu Project, il faut ouvrir un nouveau projet, avec Open Project. Donnez un nom à votre projet, par exemple, test. Un nouveau fichier PRJ sera créé. Cette fois, dans le menu PRJ, aller sur Add Item. Ajouter votre fichier .ASM, ainsi que votre fichier CPP. Donc:

PROJECT --> OPEN PROJECT
PROJECT --> ADD ITEM -> "fichier.ASM"
PROJECT --> ADD ITEM -> "fichier.CPP"

La fenêtre "Project" devrait apparaître en bas de l'écran avec la liste des fichiers que vous avez inclus. Pour rendre accessible les modules Assembleur, il faut déclarer nos fonctions avec le mot-clef "extern". Cela signifie que la définition de la fonction se trouve dans un module exterieur au C. Par
exemple:

extern "C"
{
void setmode(unsigned int mode);.

etc...
}

Maintenant, vous êtes prêt à compiler. Assurez-vous que TASM.EXE et TASM2MSG sont tous les deux présents dans votre PATH (pour être sûr, copier ces 2 fichiers dans c:\windows\command). Si tout ce passe bien, votre code asm sera compilé par TASM, et le CPP par le compilateur C. Si l'environnement Borland vous envoie un message style "Cannot find executable : TASM", il faut que vous spécifier le chemin de tasm.exe:

OPTIONS --> TRANSFER...
EDIT --> ~Turbo Assembler
PATH --> (le chemin), ex: C:\TC\BIN\

Invoquer un assembleur externe sans utiliser le fichier projet

Il est possible d’utiliser de l’assembleur beaucoup plus simplement, en l’incluant directement dans le code source. Il existe en effet une instruction du pré-processeur qui signale que l’assembleur interne doit faire place à un assembleur externe pour le traitement des lignes de codes assembleur. Il s’agit de #pragma inline. Par exemple :

// Exemple d'appel d'inline assembly par TASM

#pragma inline
asm .386p
asm MESSAGE DB "Allo de Turbo Assembleur dans C++$",13,10

void main()
{
asm MOV AX, 3
asm INT 0x10
asm MOV AH, 9
asm XOR AL,AL
asm MOV DX, OFFSET MESSAGE
asm INT 0x21
}

Programmes exemples

Les programmes exemples mettent en pratique les différentes façon d’appeler de l’assembleur dans des programmes C. Règle générale, l’assembleur interne est plus facile d’utilisation mais est moins efficace que l’assembleur externe.


ASM Mode Reel

.MODEL COMPACT                       ; modele memoire compact
.486                                 ; instructions 486
.CODE                                ; segment de code
PUBLIC _setmode,_clear,_hline,_copy  ; declaration des fonctions externes

; ----------------------------
; *	SETMODE              *
; ----------------------------

_setmode	PROC                 ; Specifie le mode video passer
                     ; en parametre
    ARG	mode:WORD            ; parametre mode
    PUSH	BP                   ; pour appel de fonctions
    MOV	BP,SP                ; par programme externe de haut niveau

    MOV	AX, mode             ; numero du mode dans AX
    INT	10h                  ; interruption video

    POP	BP                   ; sortir de la fonction
    RET                          ; fin de la fonction

_setmode	ENDP

; ----------------------------
; *          CLEAR           *
; ----------------------------

_clear		PROC
    ARG	ecran:DWORD
    PUSH	BP                  ; pour appel de fonctions
    MOV	BP,SP               ; par programme externe de haut niveau
    PUSH DI

    LES  DI,ecran               ; ES:DI pointe sur l'ecran
    MOV  CX,16000               ; 16000 iterations (64000/4)
    XOR  AX,AX                  ; AX a 0
    REP  STOSD                  ; repete deplace 4 octet de valeur AX (0)
                    ; vers ES:DI
    POP  DI
    POP	BP                  ; sortir de la fonction
    RET                         ; fin de la fonction

_clear		ENDP

; ----------------------------
; *          CLEAR           *
; ----------------------------
_copy	PROC
    ARG	ecran:DWORD
    PUSH	BP                 ; pour appel de fonctions
    MOV	BP,SP              ; par programme externe de haut niveau
    push es
    push	ds
    push	di
    push	si

    MOV  AX, 0A000h            ; destination ecran
    MOV  ES, AX
    XOR  DI, DI                ; coin superieur gauche
    LDS  SI, ecran             ; DS:SI = ecran virtuel
    MOV  CX, 16000             ; 16000 iterations (64000/4)
    REP  MOVSD                 ; repete deplace 4 octet

    pop	si
    pop	di
    pop	ds
    pop  es
    POP	BP                 ; sortir de la fonction
    RET                        ; fin de la fonction
_copy     ENDP

; ----------------------------
; *	    HLINE            *
; ----------------------------

_hline  PROC
    ARG  y:WORD, col:BYTE, ecran:DWORD

    PUSH	BP                ; pour appel de fonctions
    MOV	BP,SP             ; par programme externe de haut niveau
    PUSH DI

    LES  DI,ecran
    MOV  AX,y
    MOV  DI,AX
    SHL  DI,8
    SHL  AX,6
    ADD  DI,AX
    ADD  DI,4
    MOV  AL,col
    MOV  AH,AL
    MOV  CX,160
    REP  STOSW

     POP  DI
    POP	BP               ; sortir de la fonction
    RET                      ; fin de la fonction

_hline  ENDP

END


ASM Mode Reel

#include <time.h>
#include <conio.h>
#include <stdio.h>

#define vga 0xA000
#define MIN_Y 20
#define MAX_Y 160

char *virtuel = new char[64000L];

extern "C"
{
    void setmode(int mode);
    void clear(char *);
    void copy(char *);
    void hline(int,unsigned char,char *);
}

//----------------------------------------------------------------------//
// setpal - fixe les attributs r,g,b                                    //
//----------------------------------------------------------------------//
void setpal(unsigned char col,unsigned char r, unsigned char g, unsigned char b)
{
  outp (0x03C8,col); // Envoie les informations au DAC
  outp (0x03C9,r);
  outp (0x03C9,g);
  outp (0x03C9,b);
}

//----------------------------------------------------------------------//
// preparepal - modifie la palette a mon gout                           //
//----------------------------------------------------------------------//
void preparepal()
{
  for (int i=1;i<=10;i++)  setpal(i,0,0,i*3);
  for (i=11;i<=20;i++)	  setpal(i,(i-10)*3,0,0);
  for (i=21;i<=30;i++)	  setpal(i,0,(i-20)*3,0);
  for (i=31;i<=40;i++)     setpal(i,0,(i-30)*3,(i-30)*3);
  for (i=51;i<=60;i++)     setpal(i,(i-50)*3,(i-50)*3,(i-50)*3);
  for (i=61;i<=70;i++)     setpal(i,(i-60)*3,(i-60)*3,0);
  for (i=71;i<=80;i++)     setpal(i,(i-70)*2,(i-70)*3,(i-70));
}

//----------------------------------------------------------------------//
// Barre - Anime trois barres sur l'ecran                               //
//----------------------------------------------------------------------//
void barre(int &y, unsigned char coul, int &sens)
{
  int ligne,i,x;

  for(ligne=0;ligne<=10;ligne++)
  {
    hline(y+ligne,coul,virtuel);
    if(ligne < 5) coul++;
    if(ligne > 5) coul--;
    if(y>=MAX_Y)  sens=-1;
    if(y<=MIN_Y)  sens=1;
  }
  y+=sens;
}

void main()
{
  int sensg =  1;
  int sensb =  1;
  int sensr = -1;
  int sensv =  1;
  int sensa =  1;
  int sensc =  1;
  int sensd =  1;

  int yb = MIN_Y;
  int yr = MIN_Y + 20;
  int yg = MIN_Y + 20;
  int yv = MIN_Y + 40;
  int ya = MIN_Y + 60;
  int yc = MIN_Y + 80;
  int yd = MIN_Y + 100;
  unsigned long tempdeb, tempfin, frame;

  setmode(0x13);
  preparepal();

  frame=0;tempdeb=0;tempfin=0;
  tempdeb = clock();
  do
  {
    frame++;
    clear(virtuel);
    barre(yr,15,sensr);
    barre(yb,5, sensb);
    barre(yg,25,sensg);
    barre(yv,35,sensv);
    barre(ya,55,sensa);
    barre(yc,65,sensc);
    barre(yd,75,sensd);
    copy(virtuel);
  } while (frame < 5000);
  tempfin = clock();

  setmode(0x03);
  printf("Temps pour dessiner 5000 frames: %u\n", tempfin - tempdeb);
  printf("\nShaun Dore\ndores@videotron.ca\nhttp://pages.infinit.net/shaun/");
}


ASM Mode Reel

//----------------------------------------------------------------------//
// FICHIER              : 2DCHAP4.CPP       asmch5p3.ccp                //
// AUTEUR               : Shaun Dore                                    //
// DESCRIPTION          : Animations et ecrans virtuels                 //
// DATE DE MODIFICATION : 02-02-98	                                //
// COMPILATEUR          : Borland Turbo C++ Real Mode 16-bit compiler   //
// NOTES                : Compiler avec modele memoire Compact          //
//----------------------------------------------------------------------//

//----------------------------------------------------------------------//
// Fichiers include                                                     //
//----------------------------------------------------------------------//

#include <mem.h>
#include <time.h>
#include <stdio.h>
#include <conio.h>

//----------------------------------------------------------------------//
// Constantes                                                           //
//----------------------------------------------------------------------//

#define MIN_Y 10
#define MAX_Y 170

//----------------------------------------------------------------------//
// Variables globales                                                   //
//----------------------------------------------------------------------//

char *ecran  = (char *) (0xA0000000L);       // ptr sur RAM Video
char *virtuel = new unsigned char[64000L];   // ptr sur ecran virtuel

//----------------------------------------------------------------------//
// setmode - Appelle le mode passer en parametre                        //
//----------------------------------------------------------------------//
void setmode(unsigned int mode)
{
  asm {
       MOV AX, [mode]
       INT 0x10
     }
}

//----------------------------------------------------------------------//
// clsvirt - vide l'ecran                                               //
//----------------------------------------------------------------------//
void clsvirt()
{
  memset(virtuel,0,64000L);
}

//----------------------------------------------------------------------//
// cpyvirt - copie un ecran vers un autre                               //
//----------------------------------------------------------------------//
void cpyvirt()
{
  memcpy(ecran,virtuel,64000L);
}

//----------------------------------------------------------------------//
// putpixel - Affiche un pixel                                          //
//----------------------------------------------------------------------//
void putpixel(int x, int y, unsigned char col)
{
  virtuel[(y*320)+x] = col;
}

//----------------------------------------------------------------------//
// hline - Dessine une ligne horizontale                                //
//----------------------------------------------------------------------//
void hline(int y, unsigned char coul)
{
  memset(virtuel+(y*320),coul,320);
}

//----------------------------------------------------------------------//
// setpal - fixe les attributs r,g,b                                    //
//----------------------------------------------------------------------//
void setpal(unsigned char col,unsigned char r, unsigned char g, unsigned char b)
{
  outp (0x03C8,col); // Envoie les informations au DAC
  outp (0x03C9,r);
  outp (0x03C9,g);
  outp (0x03C9,b);
}

//----------------------------------------------------------------------//
// preparepal - modifie la palette a mon gout                           //
//----------------------------------------------------------------------//
void preparepal()
{
  for (int i=1;i<=10;i++)  setpal(i,0,0,i*3);
  for (i=11;i<=20;i++)	  setpal(i,(i-10)*3,0,0);
  for (i=21;i<=30;i++)	  setpal(i,0,(i-20)*3,0);
  for (i=31;i<=40;i++)     setpal(i,0,(i-30)*3,(i-30)*3);
  for (i=41;i<=50;i++)     setpal(i,(i-40)*3,(i-40)*3,(i-40)*3);
  for (i=61;i<=70;i++)     setpal(i,(i-60)*3,(i-60)*3,0);
  for (i=71;i<=80;i++)     setpal(i,(i-70)*2,(i-70)*3,(i-70));
}

//----------------------------------------------------------------------//
// Barre - Anime trois barres sur l'ecran                               //
//----------------------------------------------------------------------//
void barre(int &y, unsigned char coul, int &sens)
{
  int ligne,i,x;

  for(ligne=0;ligne<=10;ligne++)
  {
    hline(y+ligne,coul);
    if(ligne < 5) coul++;
    if(ligne > 5) coul--;

    if(y>=MAX_Y)  sens=-1;
    if(y<=MIN_Y)  sens=1;
  }
  y+=sens;
}

//----------------------------------------------------------------------//
// Fonction MAIN                                                        //
//----------------------------------------------------------------------//

void main()
{
  int sensg =  1;
  int sensb =  1;
  int sensr = -1;
  int sensv =  1;
  int sensa =  1;
  int sensc =  1;
  int sensd =  1;

  int yb = MIN_Y;
  int yr = MIN_Y + 20;
  int yg = MIN_Y + 20;
  int yv = MIN_Y + 40;
  int ya = MIN_Y + 60;
  int yc = MIN_Y + 80;
  int yd = MIN_Y + 100;
  unsigned long tempdeb, tempfin, frame;

  setmode(0x13);
  preparepal();

  frame=0;tempdeb=0;tempfin=0;
  tempdeb = clock();
  do
  {
    frame++;
    clsvirt();
    barre(yr,15,sensr);
    barre(yb,5, sensb);
    barre(yg,25,sensg);
    barre(yv,35,sensv);
    barre(ya,45,sensa);
    barre(yc,65,sensc);
    barre(yd,75,sensd);
    cpyvirt();
  } while (frame < 5000);
  tempfin = clock();         // clock() pour le temps de fin
  setmode(0x03);

  printf("Temps pour 5000 frames %u\n", tempfin - tempdeb);
  printf("\nShaun Dore\ndores@videotron.ca\nhttp://pages.infinit.net/shaun/");
}


Notes sur le langage C

Debug

Starts the Debug program, which you can use to test and debug executable files. Document d'origine ... http://technet.microsoft.com/en-us/library/cc722863.aspx

On This Page

Syntax debug [[drive : ][path]filename [testfile-parameters]]
Debug: A (Assemble)
Debug: C (Compare)
Debug: D (Dump)
Debug: E (Enter)
Debug: F (Fill)
Debug: G (Go)
Debug: H (Hex)
Debug: I (Input)
Debug: L (Load)
Debug: M (Move)
Debug: N (Name)
Debug: O (Output)
Debug: P (Proceed)
Debug: Q (Quit)
Debug: R (Register)
Debug: S (Search)
Debug: T (Trace)
Debug: U (Unassemble)
Debug: W (Write)
Debug: XA (Allocate Expanded Memory)
Debug: XD (Deallocate Expanded Memory)
Debug: XM (Map Expanded Memory Pages)
Debug: XS (Display Expanded-Memory Status)
Defrag
Del (Erase)
Deltree
Device
Devicehigh
Dir
Diskcomp
Diskcopy
DISPLAY.SYS
Dos
Doskey
Dosshell
DRIVER.SYS
Drivparm
Echo
Edit
EGA.SYS

Syntax debug [[drive : ][path]filename [testfile-parameters]]

Parameters

[ drive :][ path ] filename

Specifies the location and name of the executable file you want to test.

testfile-parameters

Specifies any command-line information required by the executable file you want to test.

Notes

Using the debug command without specifying a file to be tested

If you use the debug command without a location and filename, you then type all Debug commands in response to the Debug prompt, a hyphen (-).

Debug commands

Command | Description
? | Displays a list of the Debug commands.
a | Assembles 8086/8087/8088 mnemonics.
c | Compares two portions of memory.
d | Displays the contents of a portion of memory.
e | Enters data into memory starting at a specified address.
f | Fills a range of memory with specified values.
g | Runs the executable file that is in memory.
h | Performs hexadecimal arithmetic.
i | Displays one byte value from a specified port.
l | Loads the contents of a file or disk sectors into memory.
m | Copies the contents of a block of memory.
n | Specifies a file for an l or w command, or specifies the parameters for the file you are testing.
o | Sends one byte value to an output port.
p | Executes a loop, a repeated string instruction, a software interrupt, or a subroutine.
q | Stops the Debug session.
r | Displays or alters the contents of one or more registers.
s | Searches a portion of memory for a specified pattern of one or more byte values.
t | Executes one instruction and then displays the contents of all registers, the status of all flags, and the decoded form of the instruction that Debug will execute next.
u | Disassembles bytes and displays the corresponding source statements.
w | Writes the file being tested to a disk.
xa | Allocates expanded memory.
xd | Deallocates expanded memory.
xm | Maps expanded memory pages.
xs | Displays the status of expanded memory.

Separating command parameters

All Debug commands accept parameters, except the q command. You can separate parameters with commas or spaces, but these separators are required only between two hexadecimal values. Therefore, the following commands are equivalent:

dcs:100 110
d cs:100 110
d,cs:100,110

Specifying valid address entries

An address parameter in a Debug command specifies a location in memory. Address is a two-part designation containing either an alphabetic segment register or a 4-digit segment address, plus an offset value. You can omit the segment register or segment address. The default segment for the a, g, l, t, u, and w commands is CS. The default segment for all other commands is DS. All numeric values are in hexadecimal format.

The following are valid addresses:

CS:0100
04BA:0100

The colon between the segment name and the offset value is required.

Specifying valid range entries

A range parameter in a Debug command specifies a range of memory. You can choose from two formats for range: a starting address and an ending address, or a starting address and the length (denoted by l) of the range.

For example, both of the following syntaxes specify a 16-byte range beginning at CS:100:

cs:100 10f
cs:100 l 10

Related Commands

The following commands are Debug commands:

a (Assemble) | p (Proceed)
c (Compare) | q (Quit)
d (Dump) | r (Register)
e (Enter) | s (Search)
f (Fill) | t (Trace)
g (Go) | u (Unassemble)
h (Hex) | w (Write)
i (Input) | xa (Allocate Expanded Memory)
l (Load) | xd (Deallocate Expanded Memory)
m (Move) | xm (Map Extended Memory Pages)
n (Name) | xs (Display Expanded Memory Status)
0 o (Output) |
Top Of Page

Debug: A (Assemble)

Assembles 8086/8087/8088 mnemonics directly into memory.

This command creates executable machine code from assembly-language statements. All numeric values are in hexadecimal format, and you must type them as 1 to 4 characters. You specify a prefix mnemonic in front of the operation code (opcode) to which it refers.

Syntax

a [address]

Parameters

address

Specifies the location where you type assembly-language mnemonics. You use hexadecimal values for address and type each value without the trailing "h" character. If you do not specify an address, a starts assembling where it last stopped.

Notes

Using mnemonics

The segment-override mnemonics are cs:, ds:, es:, and ss:. The mnemonic for the far return is retf. String-manipulation mnemonics must explicitly state the string size. For example, use movsw to move word strings (16 bits), and use movsb to move byte strings (8 bits).

Assembling jumps and calls

The assembler automatically assembles a short, near, or far jump or call, depending on byte displacement, to the destination address. You can override such a jump or call by using a near or far prefix, as the following example shows:

â€“a0100:0500

0100:0500 jmp 502 ; a 2-byte short jump
0100:0502 jmp near 505 ;a 3-byte near jump
0100:0505 jmp far 50a ; a 5-byte far jump
You can abbreviate the near prefix to ne.

Distinguishing word and byte memory locations

When an operand can refer to either a word memory location or a byte memory location, you must specify the data type with the prefix word ptr or the prefix byte ptr. Acceptable abbreviations are wo and by, respectively. The following example shows the two formats:

dec 	 wo [si]
neg 	 byte ptr [128]

Specifying operands

Debug uses the common convention that an operand enclosed in brackets ([ ]) refers to a memory location. This is because Debug cannot otherwise differentiate between an immediate operand and an operand that is a memory location. The following example shows the two formats:

mov 	 ax,21       ; load AX with 21h
mov 	 ax,[21]     ; load AX with the
                          ; contents of
                     ; memory location 21h

Using pseudoinstructions

Two popular pseudoinstructions are available with the a command: the db opcode, which assembles byte values directly into memory, and the dw opcode, which assembles word values directly into memory. Following are examples of both pseudoinstructions:

db 1,2,3,4,"THIS IS AN EXAMPLE"
db 'THIS IS A QUOTATION MARK: "'
db "THIS IS A QUOTATION MARK: '"
dw 1000,2000,3000,"BACH"

Examples

The a command supports all forms of register-indirect commands, as the following example shows:

add bx,34[bp+2].[si-1]
pop [bp+di]
push [si]

All opcode synonyms are also supported, as the following example shows:

loopz 100
loope 100
ja      200
jnbe    200

For 8087 opcodes, you must specify the wait or fwait prefix, as the following example shows:

fwait fadd st,st(3)       ; this line assembles
                          ; an fwait prefix

Related Commands

For information about entering data into specific bytes, see the Debug e (Enter) command.

For information about disassembling bytes, see the Debug u (Unassemble) command.

Top Of Page

Debug: C (Compare)

Compares two portions of memory.

Syntax

c range address

Parameters

range

Specifies the starting and ending addresses, or the starting address and length, of the first area of memory you want to compare. For information about valid range values, see the debug command.

address

Specifies the starting address of the second area of memory you want to compare. For information about valid address values, see the debug command.

Note

If the range and address memory areas are identical, Debug displays nothing and returns directly to the Debug prompt. If there are differences, Debug displays them in the following format: address1 byte1 byte2 address2

Example

The following commands have the same effect:

c100,10f 300
c100l10 300

Each command compares the block of memory from 100h through 10Fh with the block of memory from 300h through 30Fh.

Debug responds to either of the previous commands with a display similar to the following (assuming DS = 197F):

197F:0100 4D E4 197F:0300
197F:0101 67 99 197F:0301
197F:0102 A3 27 197F:0302
197F:0103 35 F3 197F:0303
197F:0104 97 BD 197F:0304
197F:0105 04 35 197F:0305
197F:0107 76 71 197F:0307
197F:0108 E6 11 197F:0308
197F:0109 19 2C 197F:0309
197F:010A 80 0A 197F:030A
197F:010B 36 7F 197F:030B
197F:010C BE 22 197F:030C
197F:010D 83 93 197F:030D
197F:010E 49 77 197F:030E
197F:010F 4F 8A 197F:030F

Notice that the addresses 197F:0106 and 197F:0306 are missing from the list. This means that the values in those addresses are identical.

Top Of Page

Debug: D (Dump)

Displays the contents of a range of memory addresses.

Syntax

d [range]

Parameter

range

Specifies the starting and ending addresses, or the starting address and length, of the memory area whose contents you want to display. For information about valid range values, see the debug command. If you do not specify range, Debug displays the contents of 128 bytes, starting at the end of the address range specified in the previous d command.

Note

When you use the d command, Debug displays memory contents in two portions: a hexadecimal portion (each byte value is shown in hexadecimal format) and an ASCII portion (each byte value is shown as an ASCII character). Each nonprinting character is denoted by a period (.) in the ASCII portion of the display. Each display line shows the contents of 16 bytes, with a hyphen between the eighth and ninth bytes. Each display line begins on a 16-byte boundary.

Examples

Suppose you type the following command:

dcs:100 10f

Debug displays the the contents of the range in the following format:

04BA:0100 54 4F 4D 00 53 41 57 59-45 52 00 00 00 00 00 00 TOM.SAWYER......

If you type the d command without parameters, Debug formats the display as described in the previous example. Each line of the display begins with an address that is 16 bytes greater than the address on the previous line (or 8 bytes if you have a 40-column screen).

For each subsequent d command you type without parameters, Debug displays the bytes immediately following those last displayed.

If you type the following command, Debug displays the contents of 20h bytes, starting at CS:100:

dcs:100 l 20

If you type the following command, Debug displays the contents of all bytes in the range of lines from 100h through 115h in the CS segment:

dcs:100 115

Related Commands

For information about displaying the contents of registers, see the Debug r (Register) command.

For information about disassembling bytes, see the Debag u (Unassemble) command.

Top Of Page

Debug: E (Enter)

Enters data into memory at the address you specify.

You can type data in either hexadecimal or ASCII format. Any data previously stored at the specified address is lost.

Syntax

e address [list]

Parameters

address

Specifies the first memory location where you want to enter data.

list

Specifies the data you want to enter into successive bytes of memory.

Notes

Using the address parameter

If you specify a value for address without specifying a value for the optional list parameter, Debug displays the address and its contents, repeats the address on the next line, and waits for your input. At this point, you can perform one of the following actions:

  • Replace the byte value. To do this, you type a new value after the current value. If the value you type is not a valid hexadecimal value or if it contains more than two digits, Debug does not echo the invalid or extra character.

  • Advance to the next byte. To do this, you press the SPACEBAR. To change the value in that byte, type a new value after the current value. If you move beyond an 8-byte boundary when you press the SPACEBAR, Debug starts a new display line and displays the new address at the beginning of the line.

  • Return to the preceding byte. To do this, you press the HYPHEN key. You can press the HYPHEN key repeatedly to move back more than 1 byte. When you press HYPHEN, Debug starts a new line and displays the current address and byte value.

  • Stop the e command. To do this, you press the ENTER key. You can press ENTER at any byte position.

Using the list parameter

If you specify values for the list parameter, the e command sequentially replaces the existing byte values with the values from the list. If an error occurs, no byte values are changed.

List values can be either hexadecimal byte values or strings. You separate values by using a space, a comma, or a tab character. You must enclose strings within single or double quotation marks.

Examples

Suppose you type the following command:

ecs:100

Debug displays the contents of the first byte in the following format:

04BA:0100 EB._

To change this value to 41, type 41 at the cursor, as follows:

04BA:0100 EB.41_

You can type consecutive byte values with one e command. Instead of pressing ENTER after typing the new value, press the SPACEBAR. Debug displays the next value. In this example, if you press the SPACEBAR three times, Debug displays the following values:

04BA:0100 EB.41  10. 00. BC._

To change the hexadecimal value BC to 42, type 42 at the cursor, as follows:

04BA:0100 EB.41  10. 00. BC.42_

Now suppose that you decide the value 10 should be 6F. To correct this value, press the HYPHEN key twice to return to address 0101 (value 10). Debug displays the following:

04BA:0100 EB.41  10. 00. BC.42-
04BA:0102  00.-
04BA:0101  10._

Type 6f at the cursor to change the value, as follows:

04BA:0101  10.6f_

Press ENTER to stop the e command and return to the Debug prompt.

The following is an example of a string entry:

eds:100 "This is the text example"

This string will fill 24 bytes, starting at DS:100.

Related Commands

For information about assembling mnemonics, see the Debug a (Assemble) command.

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

Top Of Page

Debug: F (Fill)

Fills addresses in the specified memory area with values you specify.

You can specify data in either hexadecimal or ASCII format. Any data you previously stored at the specified address is lost.

Syntax

f range list

Parameters

range

Specifies the starting and ending addresses, or the starting address and length, of the memory area you want to fill. For information about valid range values, see the debug command.

list

Specifies the data you want to enter. List can consist of hexadecimal numbers or a string enclosed in quotation marks.

Notes

Using the range parameter

If range contains more bytes than the number of values in list, Debug assigns the values in list repeatedly until all bytes in range are filled.

If any of the memory in range is bad or doesn't exist, Debug displays an error message and stops the f command.

Using the list parameter

If list contains more values than the number of bytes in range, Debug ignores the extra values in list.

Example

Suppose you type the following command:

f04ba:100l100 42 45 52 54 41

In response, Debug fills memory locations 04BA:100 through 04BA:1FF with the values specified. Debug repeats the five values until all the 100h bytes are filled.

Top Of Page

Debug: G (Go)

Runs the program currently in memory.

Syntax

g [=address] [breakpoints]

Parameters

= address

Specifies the address in the program currently in memory at which you want execution to begin. If you do not specify address, MS-DOS begins program execution at the current address in the CS:IP registers.

breakpoints

Specifies 1 to 10 temporary breakpoints that you can set as part of the g command.

Notes

Using the address parameter

You must precede the address parameter with an equal sign (=) to distinguish the starting address (address) from the breakpoint addresses (breakpoints).

Specifying breakpoints

The program stops at the first breakpoint it encounters, regardless of where you typed that breakpoint in the breakpoints list. Debug replaces the original instruction at each breakpoint with an interrupt code.

When the program reaches a breakpoint, Debug restores all breakpoint addresses to their original instructions and displays the contents of all registers, the status of all flags, and the decoded form of the last instruction executed. Debug displays the same information as it would display if you used the Debug r (register) command and specified the breakpoint address.

If you do not stop the program at one of the breakpoints, Debug does not replace the interrupt codes with the original instructions.

Limitations on setting breakpoints

You can set breakpoints only at addresses containing the first byte of an 8086 operation code (opcode). If you set more than 10 breakpoints, Debug displays the following message:

bp Error

Requirements for the user stack pointer

The user stack pointer must be valid and must have 6 bytes available for the g command. This command uses an iret instruction to jump to the program being tested. Debug sets the user stack pointer and pushes the user flags, the code segment register, and the instruction pointer onto the user stack. (If the user stack is not valid or is too small, the operating system might fail.) Debug places an interrupt code (0CCh) at the specified breakpoint address(es).

Restarting a program

Do not attempt to restart a program after MS-DOS displays the following message:

Program terminated normally

To run the program properly, you must reload it by using the Debug n (name) and l (load) commands.

Examples

Suppose you type the following command:

gcs:7550

MS-DOS runs the program currently in memory up to the breakpoint address 7550 in the CS segment. Debug then displays the contents of the registers and the status of the flags and stops the g command.

The following command sets two breakpoints:

gcs:7550, cs:8000

If you type the g command again after Debug encounters a breakpoint, execution begins at the instruction after the breakpoint, rather than at the usual starting address.

Related Commands

For information about executing a loop, a repeated string instruction, a software interrupt, or a subroutine, see the Debug p (Proceed) command.

For information about executing one instruction, see the Debug t (Trace) command.

Top Of Page

Debug: H (Hex)

Performs hexadecimal arithmetic on two parameters you specify.

Syntax

h value1 value2

Parameters

value1

Represents any hexadecimal number in the range 0 through FFFFh.

value2

Represents a second hexadecimal number in the range 0 through FFFFh.

Note

Debug first adds the two parameters you specify and then subtracts the second parameter from the first. The results of these calculations are displayed on one line â€” first the sum, then the difference.

Example

Suppose you type the following command:

h19f 10a

Debug performs the calculations and displays the following result:

02A9 0095
Top Of Page

Debug: I (Input)

Reads and displays one byte value from the port you specify.

Syntax

i port

Parameter

port

Specifies the input port by address. The address can be a 16-bit value.

Example

Suppose you type the following command:

i2f8

Suppose also that the byte value at the port is 42h. Debug reads the byte and then displays the value, as follows:

42

Related Command

For information about sending the value of a byte to an output port, see the Debug o (Output) command.

Top Of Page

Debug: L (Load)

Loads a file or contents of specific disk sectors into memory.

To load the contents of the number of bytes specified in the BX:CX registers from a disk file, use the following syntax:

Syntax l [address]

To bypass the MS-DOS file system and directly load specific sectors, use the following syntax: l address drive start number

Parameters

address

Specifies the memory location where you want to load the file or the sector contents. If you do not specify address, Debug uses the current address in the CS register.

drive

Specifies the drive that contains the disk from which specific sectors are to be read. This value is numeric: 0 = A, 1 = B, 2 = C, and so on. You use the drive, start, and number parameters only if you want to load the contents of specific sectors rather than load the file specified on the debug command line or in the most recent Debug n (name) command.

start

Specifies the hexadecimal number of the first sector whose contents you want to load.

number

Specifies the hexadecimal number of consecutive sectors whose contents you want to load.

Notes

Using the l command without parameters

When you use the l command without parameters, the file you specified on the debug command line is loaded into memory, beginning at address CS:100. Debug also sets the BX and CX registers to the number of bytes loaded. If you did not specify a file on the debug command line, the file loaded is the one you most recently specified by using the n command.

Using the l command with the address parameter

If you use the l command with the address parameter, Debug begins loading the file or the contents of the specified sectors at the memory location address.

Using the l command with all parameters

If you use the l command with all parameters, Debug loads the contents of specific disk sectors instead of loading a file.

Loading the contents of specific sectors

Each sector in the range you specify is read from drive. Debug begins loading with start and continues until the contents of the number of sectors specified in number have been loaded.

Loading an .EXE file

Debug ignores the address parameter for .EXE files. If you specify an .EXE file, Debug relocates the file to the loading address specified in the header of the .EXE file. The header itself is stripped off the .EXE file before the file is loaded into memory, so the size of an .EXE file on disk differs from its size in memory. If you want to examine a complete .EXE file, rename the file with a different extension.

Opening a hex file

A hex file is a file that uses the Intel hexadecimal format, as described in The MS-DOS Encyclopedia. Debug assumes that files with the .HEX extension are hexadecimal-format files. You can type the l command with no parameters to load a hex file beginning at the address specified in the hex file. If the l command you type includes the address parameter, Debug adds the specified address to the address found in the hex file to determine the starting address.

Examples

Suppose you start Debug and type the following command:

nfile.com

You can now type the l command to load FILE.COM. Debug loads the file and displays the Debug prompt.

Suppose that you want to load the contents of 109 (6Dh) sectors from drive C, beginning with logical sector 15 (0Fh), into memory beginning at address 04BA:0100. To do this, type the following command:

l04ba:100 2 0f 6d

Related Commands

For information about specifying a file for the l command, see the Debug n (Name) command.

For information about writing the file being debugged to a disk, see the Debug w (Write) command.

Top Of Page

Debug: M (Move)

Copies the contents of a block of memory to another block of memory.

Syntax

m range address

Parameters

range

Specifies the starting and ending addresses, or the starting address and the length, of the memory area whose contents you want to copy.

address

Specifies the starting address of the location to which you want to copy the contents of range.

Notes

Effects of the copy operation on existing data

If the addresses in the block being copied do not have new data written to them, the original data remains intact. However, if the destination block already contains data (as it might in an overlapping copy operation), that data is overwritten. (Overlapping copy operations are those in which part of the destination block overlaps part of the source block.)

Performing overlapping copy operations

The m command performs overlapping copy operations without losing data at the destination addresses. The contents of addresses that will be overwritten are copied first. Thus, if data is to be copied from higher addresses to lower addresses, the copy operation begins at the source block's lowest address and progresses toward the highest address. Conversely, if data is to be copied from lower addresses to higher addresses, the copy operation begins at the source block's highest address and progresses toward the lowest address.

Example

Suppose you type the following command:

mcs:100 110 cs:500

Debug first copies the contents of address CS:110 to CS:510, then copies the contents of CS:10F to CS:50F, and so on until it has copied the contents of CS:100 to CS:500. To view the results, you can use the Debug d (dump) command, specifying the destination address you used with the m command.

Top Of Page

Debug: N (Name)

Specifies the name of an executable file for a Debug l (load) or w (write) command, or specifies parameters for the executable file being debugged.

Syntax

n [drive:][path]filename

To specify parameters for the executable file you are testing, use the following syntax:

n file-parameters

To clear the current specifications, use the following syntax:

n

Parameters

[ drive :][ path ] filename

Specifies the location and name of the executable file you want to test.

file-parameters

Specifies parameters and switches for the executable file you are testing.

Notes

The two uses of the n command

You can use the n command in two ways. First, you can use it to specify a file to be used by a later l or w command. If you start Debug without naming a file to be debugged, you must use the command n filename before you can use the l command to load the file. The filename is correctly formatted for a file control block at CS:5C. Second, you can use the n command to specify command-line parameters and switches for the file being debugged.

Memory areas

Memory location | Contents
CS:5C | File control block (FCB) for file 1
CS:6C | File control block (FCB) for file 2
CS:80 | Length of n command line (in characters)
CS:81 | Beginning of n command-line characters

The first filename you specify for the n command is placed in a file control block (FCB) at CS:5C. If you specify a second filename, this name is placed in an FCB at CS:6C. The number of characters typed on the n command line (exclusive of the first character, n) is stored at location CS:80. The actual characters on the n command line (again, exclusive of the letter n) are stored beginning at CS:81. Note that these characters can be any switches and delimiters that would be legal in a command typed at the MS-DOS prompt.

Examples

Suppose you've started Debug and loaded the program PROG.COM for debugging. You subsequently decide to specify two parameters for PROG.COM and run the program. Following is the sequence of commands for this example:

    debug prog.com
    nparam1 param2
    g

In this case, the Debug g (go) command runs the program as if you had typed the following command at the MS-DOS prompt:

prog param1 param2

Testing and debugging therefore reflect a typical run-time environment for PROG.COM.

In the following sequence of commands, the first n command specifies FILE1.EXE as the file for the subsequent l command, which loads FILE1.EXE into memory. The second n command specifies the parameters to be used by FILE1.EXE. Finally, the g command runs FILE1.EXE as if you had typed file1 file2.dat file3.dat at the MS-DOS prompt.

nfile1.exe
l
nfile2.dat file3.dat
g

Note that you do not use the l command after the second form of the n command. Also note that if you now use the w command, MS-DOS saves FILE1.EXE, the file being debugged, with the name FILE2.DAT. To avoid this result, you should always use the first form of the n command immediately before either an l or a w command.

Related Commands

For information about loading the contents of a file or of specific disk sectors into memory, see the Debug l (Load) command.

For information about writing the file being debugged to a disk, see the Debug w (Write) command.

Top Of Page

Debug: O (Output)

Sends the value of a byte to an output port.

Syntax

o port byte-value

Parameters

port

Specifies the output port by address. The port address can be a 16-bit value.

byte-value

Specifies the byte value you want to direct to port.

Example

To send the byte value 4Fh to the output port at address 2F8h, type the following command:

o2f8 4f

Related Command

For information about reading the value of a byte from an input port, see the Debug i (Input) command.

Top Of Page

Debug: P (Proceed)

Executes a loop, a repeated string instruction, a software interrupt, or a subroutine; or traces through any other instruction.

Syntax

p [=address] [number]

Parameters

= address

Specifies the location of the first instruction to execute. If you do not specify an address, the default address is the current address specified in the CS:IP registers.

number

Specifies the number of instructions to execute before returning control to Debug. The default value is 1.

Notes

Transferring control to the program being tested

When the p command transfers control from Debug to the program being tested, that program runs without interruption until the loop, repeated string instruction, software interrupt, or subroutine at the specified address is completed, or until the specified number of machine instructions have been executed. Control then returns to Debug.

Limitations on the address parameter

If the address parameter does not specify a segment, Debug uses the CS register of the program being tested. If you omit address, the program is executed beginning at the address specified by its CS:IP registers. You must precede the address parameter with an equal sign (=) to distinguish it from the number parameter. If the instruction at the specified address is not a loop, a repeated string instruction, a software interrupt, or a subroutine, the p command works the same way as the Debug t (trace) command.

Messages displayed with the p command

After p executes an instruction, Debug displays the contents of the program's registers, the status of its flags, and the decoded form of the next instruction to be executed.

Caution: You cannot use the p command to trace through read-only memory (ROM).

Example

Suppose that the program you're testing contains a call instruction at address CS:143F. To run the subroutine that is the destination of call and then return control to Debug, type the following command:

p=143f

Debug displays the results in the following format:

AX=0000  BX=0000  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=2246  ES=2246  SS=2246  CS=2246  IP=1443   NV UP EI PL NZ AC PO NC
2246:1442 7505          JNZ     144A

Related Commands

For information about running the program currently in memory, see the Debug g (Go) command.

For information about executing one instruction, see the Debug t (Trace) command.

Top Of Page

Debug: Q (Quit)

Stops the Debug session without saving the file currently being tested.

After you type q, control returns to MS-DOS.

Syntax q

Example

To stop the debugging session, type the following command: q

MS-DOS displays the MS-DOS prompt.

Related Command

For information about saving a file, see the Debug w (Write) command.

Top Of Page

Debug: R (Register)

Displays or alters the contents of one or more central-processing-unit (CPU) registers.

Syntax r [register-name]

To display the contents of all registers and flags in the register storage area, use the following syntax: r

Parameter

register-name

Specifies the name of the register whose contents you want to display.

Notes

Using the r command

If you specify a register name, MS-DOS displays the 16-bit value of that register in hexadecimal notation and displays a colon as the prompt. If you want to change the value contained in the register, type a new value and press ENTER; otherwise, just press ENTER to return to the Debug prompt.

Valid register names

The following are valid values for register-name: ax, bx, cx, dx, sp, bp, si, di, ds, es, ss, cs, ip, pc, and f. Both ip and pc refer to the instruction pointer.

If you specify a register name other than one from the preceding list, MS-DOS displays the following message:

br error

Using the f character instead of a register name

If you type the f character instead of a register name, Debug displays the current setting of each flag as a two-letter code and then displays the Debug prompt. To change the setting of a flag, type the appropriate two-letter code from the following table:

Flag name | Set | Clear
Overflow | ov | nv
Direction | dn (decrement) | up (increment)
Interrupt | ei (enabled) | di (disabled)
Sign | ng (negative) | pl (positive)
Zero | zr | nz
Auxiliary Carry | ac | na
Parity | pe (even) | po (odd)
Carry | cy | nc

You can type new flag values in any order. You need not leave spaces between these values. To stop the r command, press ENTER. Any flags for which you did not specify new values remain unchanged.

Messages displayed with the r command

If you specify more than one value for a flag, Debug displays the following message:

df error

If you specify a flag code not listed in the preceding table, Debug displays the following message:

bf error

In both cases, Debug ignores all settings specified after the invalid entry.

Default settings for Debug

When you start Debug, the segment registers are set to the bottom of free memory, the instruction pointer is set to 0100h, all flags are cleared, and the remaining registers are set to zero, except for sp, which is set to FFEEh.

Examples

To view the contents of all registers, the status of all flags, and the decoded form of the instruction at the current location, type the following command:

r

If the current location is CS:11A, the display will look similar to the following:

AX=0E00 BX=00FF CX=0007 DX=01FF SP=039D BP=0000 SI=005C DI=0000
DS=04BA ES=04BA SS=04BA CS=O4BA IP=011A  NV UP DI NG NZ AC PE NC
04BA:011A  CD21          INT     21

To view only the status of the flags, type the following command:

rf

Debug displays the information in the following format:

NV UP DI NG NZ AC PE NC - _

Now you can type one or more valid flag values, in any order, with or without spaces, as in the following command:

nv up di ng nz ac pe nc â€“ pleicy

Debug stops the r command and displays the Debug prompt. To see the changes, type either the r or rf command. Debug then displays the following:

NV UP EI PL NZ AC PE CY - _

Press ENTER to return to the Debug prompt.

Related Commands

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

For information about disassembling bytes, see the Debug u (Unassemble) command.

Top Of Page

Debug: S (Search)

Searches a range of addresses for a pattern of one or more byte values.

Syntax

s range list

Parameters

range

Specifies the beginning and ending addresses of the range you want to search. For information about valid values for the range parameter, see the debug command.

list

Specifies the pattern of one or more byte values or a string you want to search for. Separate each byte value from the next with a space or a comma. Enclose string values in quotation marks.

Note

If the list parameter contains more than one byte value, Debug displays only the first address where the byte value occurs. If list contains only one byte value, Debug displays all addresses where the value occurs in the specified range.

Examples

Suppose you want to find all addresses in the range CS:100 through CS:110 that contain the value 41. To do this, type the following command:

scs:100 110 41

Debug displays the results in the following format:

04BA:0104
04BA:010D
-

The following command searches for the string "Ph" in the range CS:100 through CS:1A0:

scs:100 1a0 "Ph"
Top Of Page

Debug: T (Trace)

Executes one instruction and displays the contents of all registers, the status of all flags, and the decoded form of the instruction executed.

Syntax t [=address] [number]

Parameters

= address

Specifies the address at which Debug is to start tracing instructions. If you omit the address parameter, tracing begins at the address specified by your program's CS:IP registers. For information about valid values for the address parameter, see the debug command.

number

Specifies the number of instructions to be traced. This value must be a hexadecimal number. The default value is 1.

Notes

Tracing instructions in read-only memory

The t command uses the hardware trace mode of the 8086 or 8088 microprocessor. Therefore, you can also trace instructions stored in read-only memory (ROM).

Using the address parameter

You must precede the address parameter with an equal sign (=) to distinguish it from the number parameter.

Example

To execute one instruction (pointed to by CS:IP), and then display the contents of the registers, the status of the flags, and the decoded form of the instruction, type the following command:

t

If the position of the instruction in the program were 04BA:011A, Debug might display the following information:

AX=0E00 BX=00FF CX=0007 DX=01FF SP=039D BP=0000 SI=005C DI=0000
DS=04BA ES=04BA SS=04BA CS=O4BA IP=011A  NV UP DI NG NZ AC PE NC
04BA:011A  CD21          INT     21

Related Commands

For information about executing a loop, a repeated string instruction, a software interrupt, or a subroutine, see the Debug p (Proceed) command.

For information about executing the program currently in memory, see the Debug g (Go) command.

Top Of Page

Debug: U (Unassemble)

Disassembles bytes and displays their corresponding source statements, including addresses and byte values. The disassembled code looks like a listing for an assembled file.

Syntax u [range]

To disassemble 20h bytes (the default number), beginning at the first address after the address displayed by the previous u command, use the following syntax: u

Parameter

range

Specifies the starting and ending addresses, or the starting address and length, of the code you want to disassemble. For information about valid values for the range parameter, see the debug command.

Examples

To disassemble 16 (10h) bytes, beginning at address 04BA:0100, type the following command:

u04ba:100l10

Debug displays the results in the following format:

04BA:0100  206472    AND  [SI+72],AH
04BA:0103  69        DB   69
04BA:0104  7665      JBE  016B
04BA:0106  207370    AND  [BP+DI+70],DH
04BA:0109  65        DB   65
04BA:010A  63        DB   63
04BA:010B  69        DB   69
04BA:010C  66        DB   66
04BA:010D  69        DB   69
04BA:010E  63        DB   63
04BA:010F  61        DB   61

To display only the information for the specific addresses 04BA:0100 through 04BA:0108, type the following command:

u04ba:0100 0108

Debug displays the following:

04BA:0100  206472    AND  [SI+72],AH
04BA:0103  69        DB   69
04BA:0104  7665      JBE  016B
04BA:0106  207370    AND  [BP+DI+70],DH

Related Commands

For information about assembling mnemonics, see the Debug a (Assemble) command.

For information about displaying the contents of a portion of memory, see the Debug d (Dump) command.

Top Of Page

Debug: W (Write)

Writes a file or specific sectors to disk.

You must have specified the name of the disk file when you started Debug or in the most recent Debug n (name) command. Both of these methods properly format a filename for a file control block at address CS:5C.

To write the contents of the number of bytes specified in the BX:CX registers to a disk file, use the following syntax:

Syntax w [address]

To bypass the MS-DOS file system and directly write specific sectors, use the following syntax: w address drive start number

Caution: Writing specific sectors is extremely risky because it bypasses the MS-DOS file handler. The disk's file structure can easily be damaged if the wrong values are typed.

Parameters

address

Specifies the beginning memory address of the file, or portion of the file, you want to write to a disk file. If you do not specify address, Debug starts from CS:100. For information about valid values for the address parameter, see the debug command.

drive

Specifies the drive that contains the destination disk. This value is numeric: 0 = A, 1 = B, 2 = C, and so on.

start

Specifies the hexadecimal number of the first sector to which you want to write.

number

Specifies the number of sectors to which you want to write.

Notes

Resetting BX:CX before using the w command without parameters

If you have used a Debug g (go), t (trace), p (proceed), or r (register) command, you must reset the BX:CX registers before using the w command without parameters.

Writing a modified file to a disk

If you modify the file but do not change the name, length, or starting address, Debug can still correctly write the file to the original disk location.

Limitation on the w command

You cannot write an .EXE or .HEX file with this command.

Example

Suppose you want to write the contents of memory, beginning at the address CS:100, to the disk in drive B. You want the data to begin in the disk's logical sector number 37h and continue for 2Bh sectors. To do this, type the following command:

wcs:100 1 37 2b

When the write operation is complete, Debug displays the Debug prompt again.

Related Commands

For information about specifying a file for the w command, see the Debug n (Name) command.

For information about loading the contents of a file or file sectors into memory, see the Debug l (Load) command.

Top Of Page

Debug: XA (Allocate Expanded Memory)

Allocates a specified number of pages of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

xa [count]

Parameter

count

Specifies the number of 16-kilobyte pages of expanded memory to allocate.

Example

To deallocate handle 0003, type the following command:

xd 0003

If the command is successful, Debug displays the following message:

Handle 0003 deallocated

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xd (Deallocate Expanded Memory), xm (Map Expanded-Memory Pages), and xs (Display Expanded-Memory Status).

Top Of Page

Debug: XD (Deallocate Expanded Memory)

Deallocates a handle to expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

xd [handle]

Parameters

handle

Specifies the handle you want to deallocate.

Example

To deallocate handle 0003, type the following command:

xd 0003

If the command is successful, Debug displays the following message:

Handle 0003 deallocated

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xa (allocate expanded memory), xm (map expanded-memory pages), and xs (display expanded-memory status).

Top Of Page

Debug: XM (Map Expanded Memory Pages)

Maps a logical page of expanded memory, belonging to the specified handle, to a physical page of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

xm [lpage] [ppage] [handle]

Parameters

lpage

Specifies the number of the logical page of expanded memory that you want to map to physical page ppage.

ppage

Specifies the number of the physical page to which lpage is to be mapped.

handle

Specifies the handle.

Example

To map logical page 5 of handle 0003 to physical page 2, type the following command:

xm 5 2 0003

If the command is successful, Debug displays the following message:

Logical page 05 mapped to physical page 02

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xa (Allocate Expanded Memory), xd (Deallocate Expanded Memory), and xs (Display Expanded-Memory Status).

Top Of Page

Debug: XS (Display Expanded-Memory Status)

Displays information about the status of expanded memory.

To use expanded memory, you must have installed an expanded-memory device driver that conforms to version 4.0 of the Lotus/Intel/Microsoft Expanded Memory Specification (LIM EMS).

Syntax

xs

Note

The information that Debug displays has the following format:

Handle xx has xx pages allocated
Physical page xx = Frame segment xx
xx of a total xx EMS pages have been allocated
xx of a total xx EMS handles have been allocated

Example

To display expanded-memory information, type the following command:

xs
Debug displays information similar to the following:
Handle 0000 has 0000 pages allocated
Handle 0001 has 0002 pages allocated
Physical page 00 = Frame segment C000
Physical page 01 = Frame segment C400
Physical page 02 = Frame segment C800
Physical page 03 = Frame segment CC00
 2 of a total 80 EMS pages have been allocated
 2 of a total FF EMS handles have been allocated

Related Commands

For information about other Debug commands that work with expanded memory, see the Debug commands xa (Allocate Expanded Memory), xd (Deallocate Expanded Memory), and xm (Map Expanded-Memory Pages).

Top Of Page

Defrag

Reorganizes the files on a disk to optimize disk performance. Do not use this command when you are running Windows.

Syntax

defrag [drive:] [/f] [/s[:]order] [/b] [/skiphigh] [/lcd | /bw | /g0] [/h]

defrag [drive:] [/u] [/b] [/skiphigh] [/lcd | /bw | /g0] [/h]

Parameter

drive :

Specifies the drive that contains the disk you want to optimize.

Switches

/f

Defragments files and ensures that the disk contains no empty spaces between files.

/u

Defragments files and leaves empty spaces, if any, between files.

/s

Controls how the files are sorted in their directories. If you omit this switch, defrag uses the current order on the disk. The colon (:) is optional. The following list describes each of the values you can use to sort files. Use any combination of the values, and do not separate these values with spaces.

n | In alphabetic order by name
n- | In reverse alphabetic order by name (Z through A)
e | In alphabetic order by extension
e- | In reverse alphabetic order by extension (Z through A)
d | By date and time, earliest first
d- | By date and time, latest first
s | By size, smallest first
s- | By size, largest first

/b

Restarts your computer after files have been reorganized.

/skiphigh

Loads defrag into conventional memory. By default, defrag is loaded into upper memory, if upper memory is available.

/lcd

Starts defrag using an LCD color scheme.

/bw

Starts defrag using a black and white color scheme.

/g0

Disables the graphic mouse and graphic character set.

/h

Moves hidden files.

Notes

Network and INTERLNK drives

You cannot use defrag to optimize network drives or drives created with INTERLNK.

Disk information reported by defrag and chkdsk

Disk information that defrag reports differs from information that chkdsk reports. Defrag reports hidden and user files as one number; chkdsk reports numbers for each type. Defrag counts the root as a directory; chkdsk does not. Defrag does not count the volume label as a file; chkdsk does.

Start defrag only from MS-DOS

If you start defrag from a program such as Microsoft Windows, you may lose data.

Defrag exit codes

The following list briefly describes the meaning of each defrag exit code (errorlevel parameter):

0 | The defragmentation was successful.
1 | An internal error occurred.
2 | The disk contained no free clusters. To operate, defrag needs 1 free cluster.
3 | The user pressed CTRL+C to stop the process.
4 | A general error occurred.
5 | Defrag encountered an error while reading a cluster.
6 | Defrag encountered an error while writing a cluster.
7 | An allocation error occurred. To correct the error, use the chkdsk command with the /f switch.
8 | A memory error occurred.
9 | There was insufficient memory to defragment the disk.

You can use the errorlevel parameter on the if command line in a batch program to process exit codes returned by defrag. For an example of a batch program that processes exit codes, see the diskcomp command.

Example

To load defrag into conventional memory and specify that defrag sort files according to the date they were created, from latest created to earliest created, type the following command:

defrag c: /f /sd- /skiphigh

This example fully optimizes drive C, but slows defrag.

Top Of Page

Del (Erase)

Deletes the files you specify.

Syntax

del [drive:][path]filename [/p]

erase [drive:][path]filename [/p]

Parameter

[ drive :][ path ] filename

Specifies the location and name of the file or set of files you want to delete.

Switch

/p

Prompts you for confirmation before deleting the specified file.

Notes

Using the /p switch

If you use the /p switch, del displays the name of a file and prompts you with a message in the following format:

filename, Delete (Y/N)?

Press Y to confirm the deletion, N to cancel the deletion and display the next filename (if you specified a group of files), or CRTL+C to stop the del command.

Deleting more than one file at a time

You can delete all the files in a directory by typing the del command followed by [drive:]path. You can also use wildcards (* and ?) to delete more than one file at a time. However, you should use wildcards cautiously with the del command to avoid deleting files unintentionally. Suppose you type the following command:

del *.*

Del displays the following prompt:

All files in directory will be deleted!
Are you sure (Y/N)?

Press Y and then ENTER to delete all files in the current directory, or press N and then ENTER to cancel the deletion.

Before you use wildcards with the del command to delete a group of files, you can use the same wildcards with the dir command to see a list of the names of all the files included in the group.

Caution: Once you delete a file from your disk, you may not be able to retrieve it. Although the undelete command can retrieve deleted files, it can do so with certainty only if no other files have been created or changed on the disk. If you accidentally delete a file that you want to keep, stop what you are doing and immediately use the undelete command to retrieve the file.

For more information on undeleting files, see the chapter "Managing Your System" in the MS-DOS 6 User's Guide.

Examples

To delete the CAT.TMP file from the TEST directory on drive C, you can use either of the following commands:

del c:\test\cat.tmp
erase c:\test\cat.tmp

To delete all the files in a directory named TEST on drive C, you can use either of the following commands:

del c:\test
del c:\test\*.*

Related Commands

For information about retrieving a deleted file, see the undelete command.

For information about removing a directory, see the rmdir command.

For information about deleting a directory, its files, and all subdirectories and files subordinate to it, see the deltree command.

Top Of Page

Deltree

Deletes a directory and all the files and subdirectories that are in it.

Syntax

deltree [/y] [drive:]path

Parameter

drive : path

Specifies the name of the directory you want to delete. The deltree command will delete all the files contained in the directory you specify, as well as all subdirectories and files in the subdirectories subordinate to this directory.

Switch

/y

Carries out the deltree command without first prompting you to confirm the deletion.

Notes

Deltree and Hidden, System, and Read-Only Attributes

The deltree command deletes all files contained in a directory or subdirectory, regardless of attributes.

Errorlevel parameters

If deltree successfully deleted the directory, it returns an errorlevel value of 0.

Using wildcards with deltree

You can use wildcards with the deltree command, but use them with extreme caution. If you specify a wildcard that matches both directory names and filenames, both the directories and files will be deleted. Before specifying wildcards with the deltree command, use the dir command to view the files and directories you will delete.

Example

To delete the TEMP directory on drive C, including all files and subdirectories of the TEMP directory, type the following at the command prompt:

deltree c:\temp

Related Commands

For information about removing a directory, see the rmdir command.

For information about deleting files, see the del command.

Top Of Page

Device

Loads the device driver you specify into memory. You can use this command only in your CONFIG.SYS file.

Syntax

device=[drive:][path]filename [dd-parameters]

Parameters

[ drive :][ path ] filename

Specifies the location and name of the device driver you want to load.

[ dd-parameters ]

Specifies any command-line information required by the device driver.

Notes

Using standard device drivers

The standard installable device drivers provided with MS-DOS 6 are ANSI.SYS, DISPLAY.SYS, DRIVER.SYS, DBLSPACE.SYS, EGA.SYS, EMM386.EXE, HIMEM.SYS, INTERLNK.EXE, POWER.EXE, RAMDRIVE.SYS, SETVER.EXE, and SMARTDRV.EXE.

The files COUNTRY.SYS and KEYBOARD.SYS are not device drivers. They are data files for the country and keyb commands, respectively. Do not try to load either of these files with the device command. If you do, your system halts, and you cannot restart MS-DOS. For information about loading COUNTRY.SYS, see the country command. For information about loading KEYBOARD.SYS, see the keyb command.

Installing device drivers for other products

When you purchase a mouse, a scanner, or a similar product, the manufacturer usually includes device-driver software. To install a device driver, specify its location and name on a device command line.

Installing a third-party console driver

If you install both DISPLAY.SYS and a third-party console driver, such as VT52.SYS, the third-party device driver must be installed first. Otherwise, the third-party device driver may disable DISPLAY.SYS.

Installing multiple device drivers

Sometimes one installable device driver will require that it be loaded before or after another in your CONFIG.SYS file. For example, EMM386.EXE requires HIMEM.SYS to be loaded first. If the device driver requires that another device driver be loaded before it, make sure the commands are listed in the correct order in your CONFIG.SYS file.

Example

If you plan to use an ANSI escape sequence to control the screen and keyboard, you should add the following command to your CONFIG.SYS file (assuming MS-DOS files are in the DOS directory on drive C):

device=c:\dos\ansi.sys

Related Command

For information about loading device drivers into the upper memory area, see the devicehigh command.

Top Of Page

Devicehigh

Loads device driver you specify into the upper memory area. Loading a device driver into the upper memory area frees more bytes of conventional memory for other programs. If upper memory is not available, the devicehigh command functions just like the device command.

You can use this command only in your CONFIG.SYS file.

Syntax

devicehigh [drive:][path]filename [dd-parameters]

To specify the region(s) of memory into which to load the device driver, use the following syntax:

devicehigh [[/l:region1[,minsize1][;region2[,minsize2] [/s]]= [drive:][path]filename [dd-parameters]

Parameters

[ drive :][ path ] filename

Specifies the location and name of the device driver you want to load into the upper memory area.

dd-parameters

Specifies any command-line information required by the device driver.

Switches

/l: region1 [, minsize1 ][; region2 [, minsize2 ]...

Specifies one or more regions of memory into which to load the device driver. By default, MS-DOS loads the driver into the largest free upper-memory block (UMB) and makes all other UMBs available for the driver's use. You can use the /l switch to load the device driver into a specific region of memory or to specify which region(s) the driver can use.

To load the driver into the largest block in a specific region of upper memory, specify the region number after the /l switch. For example, to load the driver into the largest free block in region 4, you would type /l:4. (To list the free areas of memory, type mem /f at the command prompt.)

When loaded with the /l switch, a device driver can use only the specified memory region. Some device drivers use more than one area of memory; for those drivers, you can specify more than one region. (To find out how a particular device driver uses memory, issue the mem /m command and specify the device-driver name as an argument.) To specify two or more regions, separate the block numbers with a semicolon (;). For example, to use blocks 2 and 3, you would type /l:2;3.

Normally, MS-DOS loads a driver into a UMB in the specified region only if that region contains a UMB larger than the driver's load size (usually equal to the size of the executable program file). If the driver requires more memory while running than it does when loaded, you can use the minsize parameter to ensure that the driver will not be loaded into a UMB that is too small for it. If you specify a value for minsize, MS-DOS loads the driver into that region only if it contains a UMB that is larger than both the driver's load size and the minsize value.

/s

Shrinks the UMB to its minimum size while the driver is loading. Using this switch makes the most efficient use of memory. This switch is normally used only by the MemMaker program, which can analyze a device driver's memory use to determine whether the /s switch can safely be used when loading that driver. This switch can be used only in conjunction with the /l switch and affects only UMBs for which a minimum size was specified.

Notes

Using the DOS=umb command

To use the devicehigh command, you must also include the DOS=umb command in your CONFIG.SYS file. If you do not specify this command, all device drivers are loaded into conventional memory, as if you had used the device command. For more information, see the DOS command.

Using MemMaker to optimize upper memory area automatically

The MemMaker program, included with MS-DOS 6, automatically optimizes your system's memory. MemMaker surveys the upper memory area, analyzes the memory use of your drivers and programs, and determines which drivers and programs fit best into the available UMBs. MemMaker then changes selected device commands in your CONFIG.SYS file to devicehigh commands and adds /l and /s switches as necessary. For more information about using MemMaker to optimize your computer's memory, see "Making More Memory Available" in the MS-DOS 6 User's Guide.

Using MS-DOS 5 devicehigh syntax

The version of devicehigh provided with MS-DOS 5 used the following syntax:

devicehigh size=hexsize [drive:][path] filename [dd-parameters]

Although the MS-DOS 5 devicehigh syntax will still work with MS-DOS 6, it is strongly recommended that you use the current devicehigh syntax whenever possible.

Installing HIMEM.SYS and a UMB provider

To load a device driver into the upper memory area, your computer must have extended memory. You must use the device command once to install the HIMEM.SYS device driver and then again to install an upper-memory-block (UMB) provider. These commands must appear before the devicehigh command in your CONFIG.SYS file. If your computer has an 80386 or 80486 processor, you can use EMM386.EXE as the UMB provider. If your computer has a different processor, you must supply a different UMB provider.

If no upper memory area is available

If there is not enough upper memory area available to load the device driver you specified with the devicehigh command, MS-DOS will load it into conventional memory (as if you had used the device command).

Examples

The following CONFIG.SYS commands make the upper memory area available for running device drivers and programs:

device=c:\\dos\\himem.sys
device=c:\\dos\\emm386.exe ram
dos=umb

The following command directs MS-DOS to load a device driver named MYDRIV.SYS into the upper memory area of an 80386 computer:

devicehigh=mydriv.sys

The following CONFIG.SYS command directs MS-DOS to run the MOUSE.SYS driver in the upper memory area and load the driver into upper memory block 2:

devicehigh=/l:2 C:\drivers\mouse.sys

The following command loads the MYDRIV.SYS driver into region 1 of upper memory, and also allows the driver to use region 3 if it needs to:

devicehigh=/l:1;3 C:\util\mydriv.sys

The following command loads the same driver into upper memory regions 1 and 3, but only if each region is at least 30 bytes in size:

devicehigh=/l:1,30;3,30 C:\util\mydriv.sys

Related Commands

For information about loading programs into the upper memory area, see the loadhigh command.

For information about loading device drivers into conventional memory, see the device command.

For information about using the MemMaker program to move programs to the upper memory area, see the memmaker command.

Top Of Page

Dir

Displays a list of the files and subdirectories that are in the directory you specify.

When you use dir without parameters or switches, it displays the disk's volume label and serial number; one directory or filename per line, including the filename extension, the file size in bytes, and the date and time the file was last modified; and the total number of files listed, their cumulative size, and the free space (in bytes) remaining on the disk.

Syntax

dir [drive:][path][filename] [/p] [/w] [/a[[:]attributes]][/o[[:]sortorder]] [/s] [/b] [/l] [/c]

Parameters

[ drive :][ path ]

Specifies the drive and directory for which you want to see a listing.

[ filename ]

Specifies a particular file or group of files for which you want to see a listing.

Switches

/p

Displays one screen of the listing at a time. To see the next screen, press any key.

/w

Displays the listing in wide format, with as many as five filenames or directory names on each line.

/a[[:] attributes ]

Displays only the names of those directories and files with the attributes you specify. If you omit this switch, dir displays the names of all files except hidden and system files. If you use this switch without specifying attributes, dir displays the names of all files, including hidden and system files. The following list describes each of the values you can use for attributes. The colon (:) is optional. Use any combination of these values, and do not separate the values with spaces.

h | Hidden files
â€“h | Files that are not hidden
s | System files
â€“s | Files other than system files
d | Directories
â€“d | Files only (not directories)
a | Files ready for archiving (backup)
â€“a | Files that have not changed since the last backup
r | Read-only files
â€“r | Files that are not read-only

/o[[:] sortorder ]

Controls the order in which dir sorts and displays directory names and filenames. If you omit this switch, dir displays the names in the order in which they occur in the directory. If you use this switch without specifying sortorder, dir displays the names of the directories, sorted in alphabetic order, and then displays the names of files, sorted in alphabetic order. The colon (:) is optional. The following list describes each of the values you can use for sortorder. Use any combination of the values, and do not separate these values with spaces.

In alphabetic order by name
â€“n | In reverse alphabetic order by name (Z through A)
e | In alphabetic order by extension
â€“e | In reverse alphabetic order by extension (Z through A)
d | By date and time, earliest first
â€“d | By date and time, latest first
s | By size, smallest first
â€“s | By size, largest first
g | With directories grouped before files
â€“g | With directories grouped after files
c | By compression ratio, lowest first.
â€“c | By compression ratio, highest first.

/s

Lists every occurrence, in the specified directory and all subdirectories, of the specified filename.

/b

Lists each directory name or filename, one per line (including the filename extension). This switch displays no heading information and no summary. The /b switch overrides the /w switch.

/l

Displays unsorted directory names and filenames in lowercase. This switch does not convert extended characters to lowercase.

/c[h]

Displays the compression ratio of files compressed using Doublespace, based on an 8K cluster size. The optional h switch displays the compression ratio of files compressed using Doublespace, based on the cluster size of the host drive. The /c[h] switch is ignored when used with the /w or /b switch.

Notes

Using wildcards with dir

You can use wildcards (* and ?) to display a listing of a subset of files and subdirectories. For an example illustrating the use of a wildcard, see the "Examples" section.

Specifying file display attributes

If you specify the /a switch with more than one value in attributes, dir displays the names of only those files with all the specified attributes. For example, if you specify the /a switch with the r and â€“h values for attributes by using either /a:r-h or /ar-h, dir displays only the names of Read-Only files that are not hidden.

Specifying filename sorting

If you specify more than one sortorder value, dir sorts the filenames by the first criterion first, then by the second criterion, and so on. For example, if you specify the /o switch with the e and â€“s values for sortorder by using either /o:e-s or /oe-s, dir sorts the names of directories and files by extension, with the largest first, and displays the final result. The alphabetic sorting by extension causes filenames with no extensions to appear first, then directory names, then filenames with extensions.

Setting date and time formats

The date and time formats used by dir depend on the country setting you use in your CONFIG.SYS file. If you don't use the country command, the formats are those for the United States.

Using redirection symbols and pipes

When you use a redirection symbol (>) to send dir output to a file or a pipe (|) to send dir output to another command, use the /a:-d and /b switches to list only the filenames. You can use the filename parameter with the /b and /s switches to specify that dir is to search the current directory and its subdirectories for all filenames that match filename. Dir lists only the drive letter, directory name, filename, and filename extension, one path per line, for each filename it finds.

Before using a pipe for redirection, you should set the TEMP environment variable in your AUTOEXEC.BAT file. Otherwise, the temporary file will appear in the directory listing.

Presetting dir parameters and switches

You can preset dir parameters and switches by including the set command with the DIRCMD environment variable in your AUTOEXEC.BAT file. You can use any valid combination of dir parameters and switches with the set DIRCMD command, including the location and name of a file.

For example, to use the DIRCMD environment variable to set the wide display format (/w) as the default format, include the following command in your AUTOEXEC.BAT file:

set dircmd=/w

For a single use of the dir command, you can override a switch set by using the DIRCMD environment variable. To do so, you use the same switch on the dir command line, but you must also precede the switch letter with a minus sign, as the following example shows:

dir /-w

You can change the DIRCMD default settings by typing the set command at the command prompt with a new parameter or switch after the equal sign (=). The new default settings are effective for all subsequent dir commands until you use set DIRCMD again on the command line or until you restart MS-DOS.

To clear all default settings, type the following command:

set dircmd=

You can view the current settings of the DIRCMD environment variable by typing the following command:

set

MS-DOS displays a list of environment variables and their settings. For more information about setting environment variables, see the set command.

Examples

Suppose you want to display all files and directories in a directory, including hidden or system files. To specify this display, type the following command:

dir /a

Suppose you want dir to display one directory listing after another, until it has displayed the listing for every directory on the disk in the current drive. Suppose also that you want dir to alphabetize each directory listing, display it in wide format, and pause after each screen. To specify such a display, be sure the root directory is the current directory and then type the following command:

dir /s/w/o/p

Dir lists the name of the root directory, the names of the subdirectories of the root directory, and the names of the files in the root directory (including extensions). Then dir lists the subdirectory names and filenames in each subdirectory in the directory tree.

To alter the preceding example so that dir displays the filenames and extensions but omits the directory names, type the following command:

dir /s/w/o/p/a:-d

To print a directory listing, type the redirection symbol and prn after any form of the dir command, as the following example shows:

dir > prn

When you specify prn on the dir command line, the directory listing is sent to the printer attached to the LPT1 port. If your printer is attached to a different port, you must replace prn with the name of the correct port.

You can also redirect output of the dir command to a file by replacing prn with a filename. A path is also accepted on the command line. For example, to direct dir output to the file DIR.DOC in the RECORDS directory, type the following command:

dir > \records\dir.doc

If DIR.DOC does not exist, MS-DOS creates it, unless the directory RECORDS also does not exist. In that case, MS-DOS displays the following message:

File creation error

To display a list of all the filenames with the .TXT extension in all directories on drive C, type the following command:

dir c:\*.txt /w/o/s/p

Dir displays, in wide format, an alphabetized list of the matching filenames in each directory and pauses each time the screen fills, until you press a key to continue.

Related Commands

For information about displaying the directory structure of a path or disk, see the tree command.

For information about compressing disks, see the dblspace command.

Top Of Page

Diskcomp

Compares the contents of two floppy disks.

This command performs a track-by-track comparison. Diskcomp determines the number of sides and sectors per track to compare based on the format of the first disk you specify.

Syntax

diskcomp [drive1: [drive2:]] [/1] [/8]

Parameters

drive1 :

Specifies the drive containing one of the floppy disks.

drive2 :

Specifies the drive containing the other floppy disk.

Switches

/1

Compares only the first sides of the disks, even if the disks are double-sided and the drives can read double-sided disks.

/8

Compares only the first 8 sectors per track, even if the disks contain 9 or 15 sectors per track.

Notes

Invalid drive for diskcomp

The diskcomp command works only with floppy disks. You cannot use diskcomp with a hard disk. If you specify a hard disk drive for drive1 or drive2, diskcomp displays the following error message:

Invalid drive specification
Specified drive does not exist
or is non-removable

Diskcomp messages

If all tracks on the two disks being compared are the same, diskcomp displays the following message:

Compare OK

If the tracks are not the same, diskcomp displays a message similar to the following:

Compare error on
side 1, track 2

When diskcomp completes the comparison, it displays the following message:

Compare another diskette (Y/N)?

If you press Y, diskcomp prompts you to insert disks for the next comparison. If you press N, diskcomp stops the comparison.

Diskcomp ignores a disk's volume number when it makes the comparison.

Omitting drive parameters

If you omit the drive2 parameter, diskcomp uses the current drive for drive2. If you omit both drive parameters, diskcomp uses the current drive for both. If the current drive is the same as drive1, diskcomp prompts you to swap disks as necessary.

Using one drive for the comparison

If you specify the same floppy disk drive for drive1 and drive2, diskcomp does a comparison by using one drive and prompts you to insert the disks as necessary. You might have to swap the disks more than once, depending on the capacity of the disks and the amount of available memory.

Comparing different types of disks

Diskcomp cannot compare a single-sided disk with a double-sided disk or a high-density disk with a double-density disk. If the disk in drive1 is not of the same type as the disk in drive2, diskcomp displays the following message:

Drive types or diskette types not compatible

Using diskcomp with networks and redirected drives

Diskcomp does not work on a network drive or on a drive created or affected by a subst command. If you attempt to use diskcomp with a network drive or a drive created by the subst command, diskcomp displays an error message.

Comparing an original disk with a copy

When you use diskcomp with a disk that you made with the copy command, diskcomp may display a message similar to the following:

    Compare error on
    side 0, track 0

This type of error can occur even if the files on the disks are identical. Although the copy command duplicates information, it doesn't necessarily place it in the same location on the destination disk. For more information about comparing individual files on two disks, see the fc command.

Diskcomp exit codes

The following list shows each exit code and gives a brief description of its meaning:

0 | The disks are the same.
1 | Differences were found.
2 | The user pressed CTRL+C to stop the process.
3 | A critical error occurred.
4 | An initialization error occurred.

You can use the errorlevel parameter on the if command line in a batch program to process exit codes returned by diskcomp.

Example

If your system has only one floppy disk drive, drive A, and you want to compare two disks, type the following command:

diskcomp a: a:

Diskcomp prompts you to insert each disk, as required.

Related Command

For information about comparing two files, see the fc command.

Top Of Page

Diskcopy

Copies the entire contents of one floppy disk to another floppy disk. Diskcopy writes over the existing contents of the destination disk as it copies the new information to it.

This command determines the number of sides to copy based on the source drive and disk.

Syntax

diskcopy [drive1: [drive2:]] [/1] [/v]

Parameters

drive1 :

Specifies the drive containing the source disk.

drive2 :

Specifies the drive containing the destination disk.

Switches

/1

Copies only the first side of a disk.

/v

Verifies that the information is copied correctly. Use of this switch slows the copying process.

Notes

Invalid drive for diskcopy

The diskcopy command works only with removable disks, such as floppy disks. You cannot use diskcopy with a hard disk. If you specify a hard disk drive for drive1 or drive2, diskcopy displays the following error message:

Invalid drive specification
Specified drive does not exist
or is non-removable

Diskcopy messages

The diskcopy command prompts you to insert the source and destination disks and waits for you to press any key before continuing.

After copying, diskcopy displays the following message:

Copy another diskette (Y/N)?

If you press Y, diskcopy prompts you to insert source and destination disks for the next copy operation. To stop the diskcopy process, press N.

If you are copying to an unformatted floppy disk in drive2, diskcopy formats the disk with the same number of sides and sectors per track as are on the disk in drive1. Diskcopy displays the following message while it formats the disk and copies the files:

Formatting while copying

If the capacity of the source disk is greater than that of the destination disk and your computer can detect this difference, diskcopy displays the following message:

Drive types or diskette types not compatible

Disk serial numbers

If the source disk has a volume serial number, diskcopy creates a new volume serial number for the destination disk and displays the number when the copy operation is complete.

Omitting drive parameters

If you omit the drive2 parameter, diskcopy uses the current drive as the destination drive. If you omit both drive parameters, diskcopy uses the current drive for both. If the current drive is the same as drive1, diskcopy prompts you to swap disks as necessary.

Using one drive for copying

If drive1 and drive2 are the same, diskcopy prompts you whenever you should switch disks. If you omit both drive parameters and the current disk drive is a floppy disk drive, diskcopy prompts you each time you should insert a disk in the drive. If the disks contain more information than available memory can hold, diskcopy cannot read all of the information at once. Diskcopy reads from the source disk, writes to the destination disk, and prompts you to insert the source disk again. This process continues until the entire disk has been copied.

Avoiding disk fragmentation

Because diskcopy makes an exact copy of the source disk on the destination disk, any fragmentation on the source disk is transferred to the destination disk. Fragmentation is the presence of small areas of unused disk space between existing files on a disk.

A fragmented source disk can slow down the finding, reading, or writing of files. To avoid transferring fragmentation from one disk to another, use either the copy command or the xcopy command to copy your disk. Because copy and xcopy copy files sequentially, the new disk is not fragmented.

Copying Startup disks

If you use the diskcopy command to copy a startup disk, the copy will also be a startup disk. If you use copy or xcopy to copy a startup disk, the copy usually will not be a startup disk.

Diskcopy exit codes

The following list shows each exit code (errorlevel parameter) and gives a brief description of its meaning:

0 | The copy operation was successful.
1 | A nonfatal read/write error occurred.
2 | The user pressed CTRL+C to stop the process.
3 | A critical error occurred.
4 | An initialization error occurred.

You can use the errorlevel parameter on the if command line in a batch program to process exit codes returned by diskcopy. For an example of a batch program that processes exit codes, see the diskcomp command.

Related Commands

For information about copying one or more files, see the copy command.

For information about copying directories and subdirectories, see the xcopy command.

For information about comparing two disks to see if they are identical, see the diskcomp command.

Top Of Page

DISPLAY.SYS

Enables you to display international character sets on EGA, VGA, and LCD monitors. This device driver must be loaded by a device or devicehigh command in your CONFIG.SYS file.

For an introduction to preparing your screen and keyboard for character sets, see the chapter "Customizing for International Use" in the MS-DOS 6 User's Guide.

Syntax

device=[drive:][path]display.sys con[:]=(type[,[hwcp][,n]])

device=[drive:][path]display.sys con[:]=(type[,[hwcp][,(n,m)]])

Parameters

[ drive :][ path ]

Specifies the location of the DISPLAY.SYS file.

type

Specifies the display adapter in use. Valid values include EGA and LCD. The EGA value supports both EGA and VGA display adapters. If you omit the type parameter, DISPLAY.SYS checks the hardware to determine which display adapter is in use. You can also specify CGA and MONO as values for type, but they have no effect because character set switching is not enabled for these devices.

hwcp

Specifies the number of the character set that your hardware supports. The following list shows the character sets that MS-DOS supports and the country/region or language for each:

437 | United States
850 | Multilingual (Latin I)
852 | Slavic (Latin II)
860 | Portuguese
863 | Canadian-French
865 | Nordic

For more information about character sets, see the appendix "Keyboard Layouts and Character Sets" in the MS-DOS 6 User's Guide.

n

Specifies the number of character sets the hardware can support in addition to the primary character set specified for the hwcp parameter. Valid values for n are in the range 0 through 6. This value depends on your hardware. For EGA display adapters, the maximum value for n is 6; for LCD display adapters, the maximum value for n is 1.

m

Specifies the number of subfonts the hardware supports for each code page. The default value is 2 if type is EGA, and 1 if type is LCD.

Notes

Using DISPLAY.SYS with monochrome or CGA display adapters

Because monochrome and CGA display adapters do not support character set switching, using DISPLAY.SYS with either type of adapter has no effect.

Installing a third-party console driver

If you install both DISPLAY.SYS and a third-party console driver, such as VT52.SYS, the third-party device driver must be installed first. Otherwise, the third-party device driver may disable DISPLAY.SYS.

Example

Suppose you want DISPLAY.SYS to support an EGA display adapter with the United States hardware character set (437) and the potential for two additional MS-DOS character sets. To do this and to specify that DISPLAY.SYS is in the DOS directory on drive C, add the following line to your CONFIG.SYS file:

device=c:\dos\display.sys con=(ega,437,2)
Top Of Page

Dos

Specifies that MS-DOS should maintain a link to the upper memory area, load part of itself into the high memory area (HMA), or both. You can use this command only in your CONFIG.SYS file.

Syntax

dos=high|low[,umb|,noumb]

dos=[high,|low,]umb|noumb

Parameters

umb|noumb

Specifies whether MS-DOS should manage upper memory blocks (UMBs) created by a UMB provider such as EMM386.EXE. The umb parameter specifies that MS-DOS should manage UMBs, if they exist. The noumb parameter specifies that MS-DOS should not manage UMBs. The default setting is noumb.

high|low

Specifies whether MS-DOS should attempt to load a part of itself into the HMA (high) or keep all of MS-DOS in conventional memory (low). The default setting is low.

Notes

Must install HIMEM.SYS for dos=umb or dos=high

You must install the HIMEM.SYS device driver or another extended memory manager before you specify either dos=umb or dos=high.

Using the umb parameter

You must specify the dos=umb command in order to load programs and device drivers into the upper memory area. Using the upper memory area frees more space in conventional memory for programs. In addition to using this command, you must install an upper-memory-block (UMB) provider. If your computer has an 80386 or 80486 processor, you can use EMM386.EXE for your UMB provider.

If you specify dos=umb and no UMB provider is installed, MS-DOS will not display an error message.

Using the high parameter

If you specify the high parameter, MS-DOS attempts to load part of itself into the HMA. Loading part of MS-DOS into the HMA frees conventional memory for programs. If you specify dos=high and MS-DOS is unable to use the HMA, the following message will appear:

HMA not available
Loading DOS low

Combining parameters

You can include more than one parameter on a single DOS command line, using commas to separate them. For example, the following command lines are valid:

dos=umb,low
dos=high,umb

You can place the dos command anywhere in your CONFIG.SYS file.

Related Commands

For information about loading a device driver into the upper memory area, see the devicehigh command.

For information about loading a program into the upper memory area, see the loadhigh command.

Top Of Page

Doskey

Loads the Doskey program into memory. The Doskey program recalls MS-DOS commands and enables you to edit command lines and create and run macros.

Doskey is a memory-resident program. When installed, Doskey occupies about 3 kilobytes of resident memory.

Syntax

doskey [/reinstall] [/bufsize=size] [/macros] [/history][/insert|/overstrike] [macroname=[text]]

To start the Doskey program and use the default settings, use the following syntax:

doskey

Parameter

macroname =[ text ]

Creates a macro that carries out one or more MS-DOS commands (a Doskey macro). Macroname specifies the name you want to assign to the macro. Text specifies the commands you want to record.

Switches

/reinstall

Installs a new copy of the Doskey program, even if one is already installed. In the latter case, the /reinstall switch also clears the buffer.

/bufsize=size

Specifies the size of the buffer in which Doskey stores commands and Doskey macros. The default size is 512 bytes. The minimum buffer size is 256 bytes.

/macros

Displays a list of all Doskey macros. You can use a redirection symbol (>) with the /macros switch to redirect the list to a file. You can abbreviate the /macros switch as /m.

/history

Displays a list of all commands stored in memory. You can use a redirection symbol (>) with the /history switch to redirect the list to a file. You can abbreviate the /history switch as /h.

/insert|/overstrike

Specifies whether new text you type is to replace old text. If you use the /insert switch, new text that you type on a line is inserted into old text (as if you had pressed the INSERT key). If you use the /overstrike switch, new text replaces old text. The default setting is /overstrike.

Notes

Recalling a command

To recall a command, you can use any of the following keys after loading Doskey into memory:

UP ARROW

Recalls the MS-DOS command you used before the one displayed.

DOWN ARROW

Recalls the MS-DOS command you used after the one displayed.

PAGE UP

Recalls the oldest MS-DOS command you used in the current session.

PAGE DOWN

Recalls the most recent MS-DOS command you used.

Editing the command line

With the Doskey program, you can edit the current command line. The following list describes the Doskey editing keys and their functions:

LEFT ARROW

Moves the cursor back one character.

RIGHT ARROW

Moves the cursor forward one character.

CTRL+LEFT ARROW

Moves the cursor back one word.

CTRL+RIGHT ARROW

Moves the cursor forward one word.

HOME

Moves the cursor to the beginning of the line.

END

Moves the cursor to the end of the line.

ESC

Clears the command from the display.

F1

Copies one character from the template to the MS-DOS command line. (The template is a memory buffer that holds the last command you typed.)

F2

Searches forward in the template for the next key you type after pressing F2. Doskey inserts the text from the template up to but not including the character you specify.

F3

Copies the remainder of the template to the command line. Doskey begins copying characters from the position in the template that corresponds to the position indicated by the cursor on the command line.

F4

Deletes characters, beginning with the current character position, up to a character you specify. To use this editing key, press F4 and type a character. Doskey deletes up to, but not including, that character.

F5

Copies the current command into the template and clears the command line.

F6

Places an end-of-file character (CTRL+Z) at the current position on the command line.

F7

Displays all commands stored in memory, with their associated numbers. Doskey assigns these numbers sequentially, beginning with 1 for the first (oldest) command stored in memory.

ALT+F7

Deletes all commands stored in memory.

F8

Searches memory for a command that you want Doskey to display. To use this editing key, type the first character, or the first few characters, of the command you want Doskey to search for and then press F8. Doskey displays the most recent command that begins with the text you typed. Press F8 repeatedly to cycle through all the commands that start with the characters you specified.

F9

Prompts you for a command number and displays the command associated with the number you specify. To display all the numbers and their associated commands, press F7.

ALT+F10

Deletes all macro definitions.

Specifying a default insert mode

If you press the INSERT key, you can type text on the Doskey command line in the middle of old text without replacing the old text. However, once you press ENTER, Doskey returns your keyboard to replace mode. You must press INSERT again to return to insert mode.

The /insert switch puts your keyboard in insert mode each time you press ENTER. Your keyboard effectively remains in insert mode until you use the /overstrike switch. You can temporarily return to replace mode by pressing the INSERT key; but once you press ENTER, Doskey returns your keyboard to insert mode.

The cursor changes shape when you use the INSERT key to change from one mode to the other.

Creating a macro

You can use the Doskey program to create macros that carry out one or more MS-DOS commands.

You can use the following special characters to control command operations when defining a macro:

$G or $g

Redirects output. Use either of these special characters to send output to a device or a file instead of to the screen. This character is equivalent to the redirection symbol for output (>).

$G$G or $g$g

Appends output to the end of a file. Use either of these special double characters to append output to an existing file rather than replace the data in the file. These double characters are equivalent to the "append" redirection symbol for output (>>).

$L or $l

Redirects input. Use either of these special characters to read input from a device or a file instead of from the keyboard. This character is equivalent to the redirection symbol for input (<).

$B or $b

Sends macro output to a command. Using one of these special characters is equivalent to using the pipe (|) on a command line.

$T or $t

Separates commands. Use either of these special characters to separate commands when you are creating macros or typing commands on the Doskey command line.

$$

Specifies the dollar-sign character ($).

$1 through $9

Represents any command-line information you want to specify when you run the macro. The special characters $1 through $9 are batch parameters, which make it possible for you to use different data on the command line each time you run the macro. The $1 character in a doskey command is similar to the %1 character in a batch program.

$*

Represents all the command-line information you want to specify when you type the macro name. The special character $* is a replaceable parameter that is similar to the batch parameters $1 through $9, with one important difference. Here, everything you type on the command line after the macro name is substituted for the $* in the macro.

For example, to create a macro that performs a quick and unconditional format of a disk, type the following command:

doskey qf=format $1 /q /u

For information about quick and unconditional formatting, see the format command.

You can use the doskey command in a batch program to create a macro.

Running a macro

To run a macro, type the macro name starting at the first position on the command line. If the macro was defined with $* or any of the batch parameters $1 through $9, use a space to separate parameters.

You could run the qf macro created in the previous example to format a disk in drive A quickly and unconditionally. To do so, you would type the following command:

qf a:

You cannot run a macro from a batch program.

Creating a macro with the same name as an MS-DOS command

You might want to create a macro that has the same name as an MS-DOS command. This can be useful, for example, if you always use a certain command with specific switches. To specify whether you want to run the macro or the MS-DOS command, follow these guidelines:

  • To run the macro, begin typing the macro name immediately after the command prompt, with no space between the prompt and the command name.

  • To carry out the command, insert one or more spaces between the command prompt and the command name.

To delete a macro, type the following command:

doskey macroname=

Examples

The /macros and /history switches are useful for creating batch programs to save macros and commands. For example, to create a batch program named MACINIT.BAT that includes all Doskey macros, type the following command:

doskey /macros > macinit.bat

To use the MACINIT.BAT file, edit it to include the doskey command at the beginning of each macro line.

To create a batch program named TMP.BAT that contains recently used commands, type the following command:

doskey /history >  tmp.bat

To define a macro with multiple commands, use $t to separate commands, as follows:

doskey tx=cd\temp$tdir/w $*

In the preceding example, the tx macro changes the current directory to TEMP and then displays a directory listing, using the wide display format. You can use $* at the end of the macro to append other switches to the dir command when you run tx.

The following macro uses a batch parameter for a new directory name. The macro first creates a new directory and then changes to it from the current directory.

doskey mc=md $1$tcd $1

To use the preceding macro to create and change to a directory named BOOKS, type the following:

mc books

To create a macro that uses batch parameters for moving a file or group of files, type the following command:

doskey mv=copy $1 $2 $t del $1

To create a macro that causes the mem command to pause after each screen, type the following command:

doskey mem=mem $* /p
Top Of Page

Dosshell

Starts MS-DOS Shell, a graphical interface to MS-DOS.

Syntax

To start MS-DOS Shell in text mode, use the following syntax:

dosshell [/t[:res[n]]] [/b]

To start MS-DOS Shell in graphics mode, use the following syntax:

dosshell [/g[:res[n]]] [/b]

Parameters

res

Specifies a screen-resolution category. Valid values are l, m, and h to specify low, medium, and high resolution, respectively. The default value of res depends on your hardware.

n

Specifies a screen resolution when there is more than one choice within a category. For information about the valid values for this parameter, see the "Notes" section. The default value of n depends on your hardware.

Switches

/t

Starts MS-DOS Shell in text mode.

/b

Starts MS-DOS Shell using a black-and-white color scheme.

/g

Starts MS-DOS Shell in graphics mode.

Notes

Running MS-DOS Shell with Microsoft Windows

Do not start Microsoft Windows from within MS-DOS Shell. If you want to use both Microsoft Windows and MS-DOS Shell, start Windows, and then start MS-DOS Shell from within Windows.

Memory requirement

To run MS-DOS Shell, you should ensure that your computer has at least 384K of available conventional memory.

Adjusting screen resolution

Once you have started MS-DOS Shell, you can adjust the screen resolution by using the Display command on the Options menu. A dialog box displays the mode (text or graphics), the number of lines, the resolution category, and the specific number within each category for all possible screen-resolution modes available for your hardware.

The DOSSHELL.INI file

Your current MS-DOS Shell settings for program items and groups, options, screen resolution, colors, and so on, are stored in a file called DOSSHELL.INI. The DOSSHELL.INI file will be updated whenever you make a change or start a program item, so it must be located on a drive that is not write-protected. You can specify the location of the DOSSHELL.INI file by setting a dosshell environment variable in your AUTOEXEC.BAT file.

For example, if the DOSSHELL.INI file is located in the DOS directory on drive C, type the following command in your AUTOEXEC.BAT file:

dosshell=c:\dos

If you customize MS-DOS Shell to suit your own needs, you should back up this file regularly. If the DOSSHELL.INI file is deleted or corrupted, a new file will be created the next time you start MS-DOS Shell.

Setting the location to store temporary files

When you run a program from MS-DOS Shell, temporary files are created in the directory where the DOSSHELL.EXE file is located. You can specify that temporary files should be placed elsewhere by setting the TEMP environment variable in your AUTOEXEC.BAT file.

Example

To start MS-DOS Shell in graphics mode, type the following command:

dosshell /g
Top Of Page

DRIVER.SYS

Creates a logical drive that you can use to refer to a physical floppy disk drive. This device driver must be loaded by a device or devicehigh command in your CONFIG.SYS file.

A logical drive is a pointer to a physical disk drive in your system. The logical drive is associated with a drive letter (for example, A or B). You can specify parameters to describe the disk drive to MS-DOS.

Syntax

device=[drive:][path]driver.sys /d:number [/c] [/f:factor] [/h:heads] [/s:sectors] [/t:tracks]

Parameter

[ drive :][ path ]

Specifies the location of the DRIVER.SYS file.

Switches

/d: number

Specifies the number of the physical floppy disk drive. Valid values for number are in the range 0 through 127. The first physical floppy disk drive (drive A) is drive 0; a second physical floppy disk drive is drive 1; a third physical floppy disk drive, which must be external, is drive 2. For a computer with one floppy disk drive, drives A and B are both numbered 0; for a computer with multiple floppy disk drives, drive B is numbered 1.

/c

Specifies that the physical disk drive can detect whether the drive door is closed (change-line support).

/f: factor

Specifies the type of disk drive. Valid values for factor are as follows:

0 | 160K/180K or 320K/360K
1 | 1.2 megabyte (MB)
2 | 720K (3.5-inch disk) or other
7 | 1.44 MB (3.5-inch disk)
9 | 2.88 MB (3.5-inch disk)

The default value for factor is 2.

Generally, if you use the /f switch, you can omit the /h, /s, and /t switches. Check the default values for these switches to make sure they are correct for the type of disk drive you are using. To determine the appropriate values for the disk drive, see the disk-drive manufacturer's documentation.

If you specify the /h, /s, and /t switches, you can omit the /f switch.

/h: heads

Specifies the number of heads in the disk drive. Valid values for heads are in the range 1 through 99. The default value is 2. To determine the correct value for your disk drive, see the disk-drive manufacturer's documentation.

/s: sectors

Specifies the number of sectors per track. Valid values for sectors are in the range 1 through 99. The default value depends on the value of /f:factor, as follows:

/f:0 /s:9 /f:1 /s:15 /f:2 /s:9 /f:7 /s:18 /f:9 /s:36

To determine the correct value for your disk drive, see the disk-drive manufacturer's documentation.

/t: tracks

Specifies the number of tracks per side on the block device. Valid values for tracks are in the range 1 through 999. The default value is 80, unless /f:factor is 0, in which case the default value is 40. To determine the correct value for your disk drive, see the disk-drive manufacturer's documentation.

Notes

Disk-drive change-line support

The term "change-line support" means that a physical disk drive can detect when the drive door is opened and closed. Change-line support allows faster MS-DOS operation with floppy disks. The /c switch indicates to MS-DOS that the physical disk drive can support change-line error detection. To determine whether your disk drive has change-line support, see the disk-drive manufacturer's documentation.

Modifying or redefining a supported physical disk drive

For information about modifying the parameters of a physical disk drive that is supported by your hardware, see the drivparm command. You can also use DRIVER.SYS to redefine a physical floppy disk drive.

Limitations on DRIVER.SYS

You cannot use DRIVER.SYS with hard disk drives. For information about substituting a logical drive letter for a hard disk drive, see the subst command.

Creating a duplicate logical drive

Suppose you want to use one physical floppy disk drive to copy files from one floppy disk to another. Because you cannot copy from and to the same logical drive by using the copy or xcopy command, you must assign a second drive letter to that physical drive.

If your system has just one physical floppy disk drive, you do not need to install DRIVER.SYS for this purpose. MS-DOS already assigns both logical drive A and logical drive B to that drive. Just copy files from drive A to drive B and switch disks when MS-DOS prompts you.

If your system has more than one floppy disk drive, then you need to use DRIVER.SYS to assign a second drive letter to the physical floppy disk drive.

Creating a new logical drive with different parameters

If you use DRIVER.SYS to assign a logical drive that has parameters different from those of the previously assigned logical drive, then the parameters of the previous logical drive will be invalid. Therefore, you should no longer use the drive letter corresponding to the previous logical drive.

Examples

To add an external 720K drive to your system, add the following line to your CONFIG.SYS file:

device=driver.sys /d:2

Since no location is specified, MS-DOS searches for DRIVER.SYS in the root directory of your startup drive.

Suppose you want to use a single 1.44-megabyte external disk drive to copy files from one floppy disk to another. To do this, you must add two identical device commands for DRIVER.SYS in your CONFIG.SYS file. This procedure assigns two logical drive letters to the same physical drive. You can then swap disks in the same drive during the copying process. The following example shows how to do this:

device=driver.sys /d:2 /f:7
device=driver.sys /d:2 /f:7
Top Of Page

Drivparm

Defines parameters for devices such as disk and tape drives when you start MS-DOS. You can use this command only in your CONFIG.SYS file.

The drivparm command modifies the parameters of an existing physical drive. It does not create a new logical drive. The settings specified in the drivparm command override the driver definitions for any previous block device.

Syntax

drivparm=/d:number [/c] [/f:factor] [/h:heads] [/i] [/n] [/s:sectors] [/t:tracks]

Switches

/d: number

Specifies the physical drive number. Values for number must be in the range 0 through 255 (for example, drive number 0 = drive A, 1 = drive B, 2 = drive C, and so on).

/c

Specifies that the drive can detect whether the drive door is closed.

/f: factor

Specifies the drive type. The following list shows the valid values for factor and a brief description of each. The default value is 2.

0 | 160K/180K or 320K/360K
1 | 1.2 megabyte (MB)
2 | 720K (3.5-inch disk)
5 | Hard disk
6 | Tape
7 | 1.44 MB (3.5-inch disk)
8 | Read/write optical disk
9 | 2.88 MB (3.5-inch disk)

/h: heads

Specifies the maximum number of heads. Values for heads must be in the range 1 through 99. The default value depends upon the value you specify for /f:factor.

/i

Specifies an electronically compatible 3.5-inch floppy disk drive. (Electronically compatible drives are installed on your computer and use your existing floppy-disk-drive controller.) Use the /i switch if your computer's ROM BIOS does not support 3.5-inch floppy disk drives.

/n

Specifies a non-removable block device.

/s: sectors

Specifies the number of sectors per track that the block device supports. Values for sectors must be in the range 1 through 99. The default value depends upon the value you specify for /f:factor.

/t: tracks

Specifies the number of tracks per side that the block device supports. The default value depends upon the value you specify for /f:factor.

Notes

Using the /i switch

Use the /i switch if your system does not support 3.5-inch floppy disk drives. (Some IBM PC/AT-compatible systems do not have a ROM BIOS that supports 3.5-inch floppy disk drives.)

Disk drive change-line support

Change-line support means that a physical disk drive can detect whether the drive door is opened and closed. Change-line support improves performance by letting MS-DOS know when one floppy disk has been replaced by another. The /c switch allows MS-DOS to make use of change-line support. To find out whether your disk drive has change-line support, see your disk-drive documentation.

Creating a logical drive

Drivparm modifies the parameters of an existing physical drive and does not create a new logical drive.

Example

Suppose your system has an internal tape drive with one head on drive D that is configured at startup to write 20 tracks of 40 sectors per track. To reconfigure this tape drive to write 10 tracks of 99 sectors each, add the following command to your CONFIG.SYS file:

drivparm=/d:3 /f:6 /h:1 /s:99 /t:10
Top Of Page

Echo

Displays or hides the text in batch programs when the program is running. Also indicates whether the command-echoing feature is on or off.

When you run a batch program, MS-DOS typically displays (echoes) the batch program's commands on the screen. You can turn this feature on or off by using the echo command.

Syntax

echo [on|off]

To use the echo command to display a message, use the following syntax:

echo [message]

Parameters

on|off

Specifies whether to turn the command-echoing feature on or off. To display the current echo setting, use the echo command without a parameter.

message

Specifies text you want MS-DOS to display on the screen.

Notes

Using a message with the echo command

The echo message command is useful when echo is off. To display a message that is several lines long without displaying other commands, you can include several echo message commands after the echo off command in your batch program.

Hiding the command prompt

If you use the echo off command on the command line, the command prompt does not appear on your screen. To redisplay the command prompt, type echo on.

Preventing MS-DOS from echoing a line

You can insert an at sign (@) in front of a command in a batch program to prevent MS-DOS from echoing that line.

Echoing a blank line

To echo a blank line on the screen, you can type echo and then a period (echo.). There must be no intervening space.

Displaying pipes and redirection characters

You cannot display a pipe (|) or redirection character (< or >) by using the echo command.

Examples

The following example shows a batch program that includes a three-line message preceded and followed by a blank line:

echo off
echo.
echo This batch program
echo formats and checks
echo new disks
echo.

If you want to turn echo off and you do not want to echo the echo command itself, include an at sign (@) before the command, as follows:

@echo off

You can use the if and echo commands on the same command line, as follows:

if exist *.rpt echo The report has arrived.

Related Command

For information about suspending the execution of a batch program, see the pause command.

Top Of Page

Edit

Starts MS-DOS Editor, a text editor you can use to create and edit ASCII text files.

MS-DOS Editor is a full-screen editor that allows you to create, edit, save, and print ASCII text files. Using MS-DOS Editor, you can choose commands from menus and specify information and preferences in dialog boxes. MS-DOS Editor includes extensive online Help about MS-DOS Editor techniques and commands.

Syntax

edit [[drive:][path]filename] [/b] [/g] [/h] [/nohi]

Parameter

[ drive :][ path ] filename

Specifies the location and name of an ASCII text file. If the file does not exist, MS-DOS Editor creates it. If the file exists, MS-DOS Editor opens it and displays its contents on the screen.

Switches

/b

Displays MS-DOS Editor in black and white. Use this option if MS-DOS Editor isn't displayed correctly on a monochrome monitor.

/g

Uses the fastest screen updating for a CGA monitor.

/h

Displays the maximum number of lines possible for the monitor you are using.

/nohi

Enables you to use 8-color monitors with MS-DOS Editor. Usually, MS-DOS uses 16 colors.

Caution: MS-DOS Editor does not work if the file QBASIC.EXE is not in the current directory or in the search path or in the same directory as the file EDIT.COM. If you delete QBASIC.EXE to save space on your hard disk, you cannot use MS-DOS Editor.

Note

Note: Some monitors may not support the display of shortcut keys by default. If your monitor does not display shortcut keys, use the /b switch (for CGA monitors) and the /nohi switch (for systems that do not support bold characters).

Top Of Page

EGA.SYS

Saves and restores the display when the MS-DOS Shell Task Swapper is used with EGA monitors. If you have an EGA monitor, you must install the EGA.SYS device driver before using Task Swapper. This device driver must be loaded by a device or devicehigh command in your CONFIG.SYS file.

Syntax

device=[drive:][path]ega.sys

Parameters

[ drive :][ path ]

Specifies the location of the EGA.SYS file.

Note

If you are using a mouse on a system that has an EGA monitor, you can save memory by installing EGA.SYS before you install your mouse driver.


Notes sur le langage C

Sponsoring website: Emergency Boot CD

  • I hope you enjoy the Assembly coding examples used on this page. If you have any questions about them, use this online form to e-mail me. ( Opens in a new window. )

A Guide to DEBUG
(Page Two)
A DEBUG Tutorial
Copyright©2005,2009 by Daniel B. Sedory

This page may be freely copied for PERSONAL use ONLY !
( It may NOT be used for ANY other purpose unless you have
first contacted and received permission from the author! )

  • Each Command -- Listed Alphabetically
    • Quick Links to Command Help

  • How to Use the COMMANDS
    • Meaning of Command Parameters

    • Detailed Help on each Command (begins here)
      • An Example Program for you to Enter, Run and Edit under DEBUG.
      • A Note about Win 9x's 'IHC' string in Diskette Boot Sectors

  • Appendixes
    • The 8086 CPU Registers
    • The FLAGS Register
    • The Segment:Offset Addressing method used by DEBUG

Help on DEBUG Commands

For a reminder of all the commands (and most of the parameters) that are available while inside of DEBUG, simply enter a question mark (?) at the DEBUG prompt; when using DOS 5.0 or later. ( Note: Expanded Memory commands are rarely if ever used and will not be discussed here.)

Quick Alphabetical Links
Click on a command here for all its details:

  • -?
assemble    A [address]
compare     C range address
dump        D [range]
enter       E address [list]
fill        F range list
go          G [=address] [addresses]
hex         H value1 value2   (Learn 2's Complement!)
input       I port
load        L [address] [drive] [firstsector] [number]
move        M range address
name        N [pathname] [arglist]
output      O port byte
proceed     P [=address] [number]
quit        Q . . . . . . . . . (Learn this first!)
register    R [register]
search      S range list
trace/step  T [=address] [number]
unassemble  U [range]
write       W [address] [drive] [firstsector] [number]

H o w t o u s e t h e C O M M A N D S

P a r a m e t e r s

NOTE: Parameters listed in brackets ( [ ] ) are optional. Optional parameters usually indicate there are a number of different ways a command could be used. I've listed the meanings of all the parameters here for you:

address - Memory location specified in hexadecimal. You can use either a simple Offset all by itself (in which case, the present CS 'Code Segment' will be assumed), or you can enter the full Segment:Offset location using either all hex numbers or substituting the name of a segment register for a number. Leading zeros are not required; thus 1F all by itself would be the location 'CS:001F' ( CS meaning whatever the CS happened to be at the time you entered this ). Examples:

    100    DS:12    SS:0    198A:1234
For a detailed discussion, see: Segment:Offset notation.

range - Two hexadecimal addresses separated by a single space. They may be listed as either full Segment:Offset pairs or just an Offset alone ( in which case, the Segment is assumed to be that of the present CS or "Code Segment" ). NOTE: Some commands, such as Compare (C), may require the second address be given only as an offset.

list - A string of Hexadecimal bytes separated by a space, or ASCII data enclosed within single or double quote marks. You can list any number of bytes from a single one up whatever number fits on the line before having to press the Enter key. A single byte, such as 00 is most often used with the FILL (f) command whereas an ENTER (e) command will most likely have a string of many hex bytes or ASCII characters per line; for example:
    e 100 31 C0 B4 09 BA 50 02 CD 21 B8 4C 00 CD 21

    e 250 'This is an ASCII data string.$'

number - Remember all numbers and values used in any DEBUG command are understood as being Hexadecimal only! That includes the number of sectors in the LOAD or WRITE commands and even the number of instructions you want DEBUG to step through in the TRACE or PROCEED commands. It's all HEX all the time when using DEBUG!

A Simple DEBUG Tutorial

Details of each Command

NOTE: In the Examples below, commands which are entered by a user are shown in bold type; data displayed in response by DEBUG is in normal type. DEBUG (from MS-DOS 5.0 or later (which is true for the DEBUG version used by Windows™ XP) will display the following usage message, if you enter debug /?  at a DOS prompt:

C:\WINDOWS>debug /?
Runs Debug, a program testing and editing tool.

DEBUG [[drive:][path]filename [testfile-parameters]]

  [drive:][path]filename  Specifies the file you want to test.
  testfile-parameters     Specifies command-line information required by
                          the file you want to test.
    Quit:  Q

Immediately quits (exits) the Debug program! No questions ever asked... should be the first command you remember along with the "?" command.

Back to TOC

    Hex:  H  value1  value2
A very simple (add and subtract only) Hex calculator. Never forget that all numbers inside of DEBUG are always Hexadecimal. Enter two Hex values (no more than four digits each) and DEBUG shows first the SUM, then the DIFFERENCE of those values. Examples:
   -h aaa 531    -h fff 3      -h dbf ace
   0FDB  0579    1002  0FFC    188D  02F1
   -             -             -

Differences are always the second value subtracted from the first;AAA - 531 = 579. There are no carries past four digits.

Two's Complement arithmetic is always used in this calculator, so think of it as being limited to a maximum of plus 7FFFh (+ 32,767) or a minimum of minus 8000h (- 32,768). Positive values are represented by exactly the same digits as their numbers for 0000h through 7FFFh. A minus 7FFFh, however, is represented by the Hex digits 8001, and a minus 1h (-1) is represented by the Hex digits FFFF. Thus, the output of DEBUG after entering "h 4 fffc" would be a zero and an 8, because FFFC represents a minus 4h (-4) and 4 - (-4) = 8. Examples:

   -h 4 fffc    -h 100 123    -h 7fff 8000
   0000 0008    0223  FFDD    FFFF FFFF
   -            -             -
Note the difference between 100h and 123h; what does FFDD represent? To find the numerical value of a Two's Complement number, first invert every bit (or find its logical inverse); that would be 0022, then add 1. So, this represents a negative 23h. Both the sum and the difference of 7FFFh and 8000h are a negative 1 (or FFFF); which can be arrived at using: 7FFFh + (- 8000h) = -1. However, it's much easier to think of the sums as having nothing to do with Two's Complement notation; thus, 7FFFh + 8000h = FFFFh (32,767 + 32,768 = 65,535). This will even hold true for the differencesif the second value is less than the first. But any difference which produces a negative number, must be represented in Two's Complement.

Back to TOC

   Dump:  D  [range]
          D  [address]  [length]

Displays the contents of a block of memory. The Memory locations near the beginning of Segment C000 (even under Windows 2000/XP) should display information about the kind of video card installed on your PC. The first example below shows what a Matrox video card on our system displayed.

Examples:

-d c000:0010
C000:0010 24 12 FF FF 00 00 00 00-60 00 00 00 00 20 49 42  $.......`.... IB
C000:0020 4D 20 43 4F 4D 50 41 54-49 42 4C 45 20 4D 41 54  M COMPATIBLE MAT
C000:0030 52 4F 58 2F 4D 47 41 2D-47 31 30 30 20 56 47 41  ROX/MGA-G100 VGA
C000:0040 2F 56 42 45 20 42 49 4F-53 20 28 56 31 2E 32 20  /VBE BIOS (V1.2
C000:0050 29 00 87 DB 87 DB 87 DB-87 DB 87 DB 87 DB 87 DB  )...............
C000:0060 50 43 49 52 2B 10 01 10-00 00 18 00 00 00 00 03  PCIR+...........
C000:0070 40 00 12 10 00 80 00 00-38 37 34 2D 32 00 FF FF  @.......874-2...
C000:0080 E8 26 56 8B D8 E8 C6 56-74 22 8C C8 3D 00 C0 74  .&V....Vt"..=..t
-
-d 100 130
xxxx:0100 EB 24 0D 0A 54 68 69 73-20 69 73 20 6D 79 20 66  .$..This is my f
xxxx:0110 69 72 73 74 20 44 45 42-55 47 20 70 72 6F 67 72  irst DEBUG progr
xxxx:0120 61 6D 21 0D 0A 24 B4 09-BA 02 01 CD 21 B4 00 CD  am!..$......!...
xxxx:0130 21                                               !
-
The last example above, is what you'd see after entering the code under the Assemble command. We could just as easily have used the length option with the command 'd 100 l31' (that's an 'L' in front of the "31") to produce the same results above. The following example shows only the '$'-terminated display string, which has a length of 24h bytes (remember numbers in DEBUG are always hexadecimal); so that's 36 in decimal:
-d 102 l24
xxxx:0100       0D 0A 54 68 69 73-20 69 73 20 6D 79 20 66    ..This is my f
xxxx:0110 69 72 73 74 20 44 45 42-55 47 20 70 72 6F 67 72  irst DEBUG progr
xxxx:0120 61 6D 21 0D 0A 24                                am!..$
-

Back to TOC

  Search:  S  range  list

Searches within a range of addresses for a pattern of one or more byte values given in a list. The list can be comprised of numbers or character strings enclosed by matching single or double quote marks. [ NOTE: In the examples below, if you do find the same data on your computer, the locations could easily vary from ours! ]

Examples:

-s fe00:0 ffff "BIOS"
FE00:0021
FE00:006F

-d fe00:0
FE00:0000 41 77 61 72 64 20 53 6F-66 74 77 61 72 65 49 42  Award SoftwareIB
FE00:0010 4D 20 43 4F 4D 50 41 54-49 42 4C 45 20 34 38 36  M COMPATIBLE 486
FE00:0020 20 42 49 4F 53 20 43 4F-50 59 52 49 47 48 54 20   BIOS COPYRIGHT
FE00:0030 41 77 61 72 64 20 53 6F-66 74 77 61 72 65 20 49  Award Software I
FE00:0040 6E 63 2E 6F 66 74 77 61-72 65 20 49 6E 63 2E 20  nc.oftware Inc.
FE00:0050 41 77 03 0C 04 01 01 6F-66 74 77 E9 12 14 20 43  Aw.....oftw... C
FE00:0060 1B 41 77 61 72 64 20 4D-6F 64 75 6C 61 72 20 42  .Award Modular B
FE00:0070 49 4F 53 20 76 34 2E 35-31 50 47 00 DB 32 EC 33  IOS v4.51PG..2.3

-s 0:0 dff 'A20'
0000:0C42

-d 0:c40
0000:0C40 0D 0A 41 32 30 20 68 61-72 64 77 61 72 65 20 65  ..A20 hardware e
0000:0C50 72 72 6F 72 2E 20 20 43-6F 6E 74 61 63 74 20 74  rror.  Contact t
0000:0C60 65 63 68 6E 69 63 61 6C-20 73 75 70 70 6F 72 74  echnical support
0000:0C70 20 74 6F 20 69 64 65 6E-74 69 66 79 20 74 68 65   to identify the
0000:0C80 20 70 72 6F 62 6C 65 6D-2E 0D 0A 24 1A 00 BA F6   problem...$....

-s 0:0 dff 43 4f 4d
0000:0774
0000:07C2
0000:07D4
0000:07E6

-d 0:770
0000:0770 7A 02 A6 02 43 4F 4D 31-20 20 20 20 8E 00 70 00  z...COM1    ..p.
0000:0780 C0 A0 7A 02 91 02 4C 50-54 31 20 20 20 20 A0 00  ..z...LPT1    ..
0000:0790 70 00 C0 A0 7A 02 98 02-4C 50 54 32 20 20 20 20  p...z...LPT2
0000:07A0 2D 01 70 00 C0 A0 7A 02-9F 02 4C 50 54 33 20 20  -.p...z...LPT3
0000:07B0 20 20 11 EA 27 27 3F FD-CA 00 70 00 00 80 7A 02    ..''?...p...z.
0000:07C0 AC 02 43 4F 4D 32 20 20-20 20 DC 00 70 00 00 80  ..COM2    ..p...
0000:07D0 7A 02 B2 02 43 4F 4D 33-20 20 20 20 00 00 6B 03  z...COM3    ..k.
0000:07E0 00 80 7A 02 B8 02 43 4F-4D 34 20 20 20 20 E8 D2  ..z...COM4    ..

Back to TOC

Compare:  C  range  address
Compares two blocks of memory. If there are no differences, then DEBUG simply displays another prompt (-). Here's an example of what happens when there are differences:
     -c 140 148 340
     127D:0143  30  6D  127D:0343
     127D:0146  10  63  127D:0346
     127D:0148  49  30  127D:0348
The bytes at locations 140 through 148 are being compared to those at 340 ( through 348, implied ); the bytes are displayed side by side for those which are different (with their exact locations, including the segment, on either side of them).

Back to TOC

   Fill:  F  range  list
This command can also be used to clear a whole segment of Memory as well as filling smaller areas with a continuously repeating phrase or single byte. Examples:
-f 100 12f 'BUFFER'
-d 100 12f
xxxx:0100  42 55 46 46 45 52 42 55-46 46 45 52 42 55 46 46 BUFFERBUFFERBUFF
xxxx:0110  45 52 42 55 46 46 45 52-42 55 46 46 45 52 42 55 ERBUFFERBUFFERBU
xxxx:0120  46 46 45 52 42 55 46 46-45 52 42 55 46 46 45 52 FFERBUFFERBUFFER

-f 100 ffff 0

This last example fills almost all of the assigned Segment with zero bytes (which can also be thought of as clearing the Segment). You should use this command whenever you want to be sure the bytes you'll be looking at in DEBUG's Segment are those you entered or loaded, or bytes DEBUG has changed; not soem previously used bytes from memory! If you want to examine a file from a disk in a 'clean' Segment, you'll first have to start DEBUG without any filename, clear the Segment using: f 100 ffff 0 and then finally load the file using the Name (n) and Load (L) commands in that order.

NOTE: Filling (clearing) any bytes in the area from 00h through FFh of our Segment can sometimes lead to problems; especially when file I/O is involved. DEBUG stores data for its own use in those locations, so we recommend you never overwrite bytes in that area; unless you have a reason for doing so!

Example: A student in an Assembly class was told to enter a string of commands under DEBUG, the last one being: JMP 0 which he was supposed to Trace (T) to the next command and then execute it. He was told it would be an INT 20 instruction. Well in most cases this is true, because DEBUG always sets the first two bytes of its working segment to "CD 20" for just this purpose. Let's test this out. First, open a new instance of DEBUG, then enter the following commands:

-f 100 ffff 0    [Zero-out 100 through FFFF]
-e 100 e9 fd fe  [Enters a 'JMP 0' at 100]
-u 100 102       [Check for correct entry]
xxxx:0100 E9FDFE        JMP     0000
-r
AX=0000  BX=0000  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=xxxx  ES=xxxx  SS=xxxx  CS=xxxx  IP=0100   NV UP EI PL NZ NA PO NC
xxxx:0100 E9FDFE        JMP     0000
-u 0 1
xxxx:0000 CD20          INT     20

If you don't see "INT 20" after entering "u 0 1", then restart DEBUG and try again.

-t  [The "T"(Trace) command]

AX=0000  BX=0000  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=xxxx  ES=xxxx  SS=xxxx  CS=xxxx  IP=0000   NV UP EI PL NZ NA PO NC
xxxx:0000 CD20          INT     20
-p  [Always make sure you use a "P"(Proceed) command for Interrupts!]

Program terminated normally
-q  [Quit]

Well, this never worked for those students. Why? Because the teacher had mistakenly told them to Fill the whole segment with zero bytes (f 0 ffff 0), in essence telling them to delete the very instruction he'd wanted them to execute!

Back to TOC

  Enter:  E  address  [list]
Used to enter data or instructions (as machine code) directly into Memory locations.
Example. First we'll change a single byte at location CS:FFCB from whatever it was before to D2 :
   -e ffcb d2
This next example shows that either single(') or double(") quote marks are acceptable for entering ASCII data. By allowing both forms, entry strings can be created to include either type of quote mark as data:
   -e 200 'An "ASCII-Z string" is always followed by '
   -e 22a "a zero-byte ('00h')." 0
But in order to enter more than a single line of ASCII data, the A (Assemble) command is more practical since it will calculate the next offset for you! (See that command for a Memory dump of these bytes.) Now we'll examine a string of 11 hex bytes you can enter into Memory at locations CS:0100 and following:
   -e 100 B4 09 BA 0B 01 CD 21 B4 00 CD 21
This is actually machine code for a program that will display whatever ASCII characters it finds at locations CS:010B and following, until it encounters a byte value of 24h (a $ sign). If you want to run this program, we'd recommend entering 24h at offset location 7EAh of the Segment so the program will terminate there:
   -e 7ea 24
   -g =100
And you'll soon see: "Program terminated normally" on the display screen. Why did we pick 7EAh? Because many DOS screens are set to display only 25 lines of 80 (50h) characters, and this value allows you to view the maximum number of characters possible on a single screen between the "Go," termination and prompt ("-") lines.

Here's something a bit more interesting for you to try out: It's essentially the same program, but the data includes all of the byte values from 00h through FFh; except for 24h which we placed at the end of the last line. The DEBUG prompt symbol, - , has been purposely excluded from the lines below, so you can copy and paste the whole block into a DEBUG DOS-box (Help on using DOS-Window controls is here if needed):

e 100 B4 09 BA 0B 01 CD 21 B4 00 CD 21 0D 0A 0D 0A 00 01 02
e 112 03 04 05 06 07 08 09 20 0B 0C 20 0E 0F 10 11 12 13 14
e 124 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 20 25 26
e 136 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38
e 148 39 3A 3B 3C 3D 3E 3F 0D 0A 0D 0A 40 41 42 43 44 45 46
e 15a 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58
e 16c 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A
e 17e 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C
e 190 7D 7E 7F 0D 0A 0D 0A 80 81 82 83 84 85 86 87 88 89 8A
e 1a2 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C
e 1b4 9D 9E 9F a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB aC aD aE
e 1c6 aF b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 bA bB bC bD bE bF 0D
e 1d8 0A 0D 0A c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 cA cB cC cD cE
e 1ea cF d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 dA dB dC dD dE dF e0
e 1fc e1 e2 e3 e4 e5 e6 e7 e8 e9 eA eB eC eD eE eF f0 f1 f2
e 20e f3 f4 f5 f6 f7 f8 f9 fA fB fC fD fE fF 0D 0A 0D 0A 24

The bytes 0Dh and 0Ah produce a Carriage Return and Linefeed on the display, so we replaced them in the listing above by 20h; a SPACE byte. The 24h byte was moved to the end of the program with another 20h taking its place. The bytes shown above in blue (0D 0A 0D 0A) form blank lines at the beginning of the output and after every 64 bytes for a nice formatted display.

Therefore, when the program is run, we should see four separate lines of 64 characters each (a few of those being blank spaces as mentioned above), right? Well, let's find out: Start DEBUG in a DOS-Window, copy and paste the lines above into DEBUG at its prompt symbol, then enter the following command:

     g =100    ( 'g' followed by a SPACE, then '=100')

This will immediately run (see Go command) the program, displaying the output lines followed by: "Program terminated normally" [ Do not exit DEBUG, just leave the window open. We're going to show you how to 'patch' this code and save the results as a nice little console program ].

Were you surprised to find more than four spaces on the first line; starting with the very first byte? What about the fact we appear to have missing characters at the end of that line? We'll briefly explain why the characters appeared this way on your screen, but in order to create programs of your own, you'll need to study about control characters, Interrupts and what effect different BIOS and DOS video functions have on the way ASCII characters are displayed. OK, here's what happened:

First, the Zero byte also displays as a blank space here. The 07 byte may make a beep or ding sound (but does not display anything), 08 performs a BACKSPACE (erasing the 06 byte character) and 09 is a TAB -- which may jump up to eight columns to the right before reaching the next 'Tab Stop.' But since it just happens to begin in column seven, it only moves one column to the right where our program places the space we substituted for 0Ah. Lastly, for some reason, when using Function 09 of INT 21h ("Display a string of characters until a '$' sign is encountered"), the ESC character (1Bh; 27 decimal) doesn't display or do anything. So, after reaching the end of the first line, it only appeared as if many of the characters we expected to see were never displayed. In reality, the last three characters are there. It's because of the bytes 07h (displayed nothing), 08h (only backspaced over 06h), 09h (displayed nothing, but moved cursor forward one byte) and 1Bh (displayed nothing) that we saw what we did.

Enter the following two lines into DEBUG (which contain more blank-space substitutions), run the program again, and you'll see all the displayable characters output on the first line in their correct positions:

e 10F 00 01 02 03 04 05 06 20 20 20 20 0B 0C 20
e 11D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 20
All four rows will display evenly in size, including the last one. But the last character, FFh (255 decimal), just like the first, also displays as a blank space here! You can prove this by inserting another byte such as 2Eh (a period '.') after FFh. We've created the following patch which effectively moves up the remainder of the program after the FFh by one:

e 21b 2e 0d 0a 0d 0a 24

After patching and running it again, the program output should look like this:

If you want to, you can save this code as an executable program by first giving it a path and filename (such as, C:\TEMP\ASCIIDSP.COM; see Name command) and writing the bytes (see Write command) to a file like this:

   -n c:\temp\asciidsp.com
   -rcx
   CX0000
   :121       [ Program Length = 220h - 100h + 1 = 121h ]
   -w

If you check the file properties of ASCIIDSP.COM, its size should be 289 bytes.

Back to TOC

     Go:  G  [=address]  [addresses]

Go is used to run a program and set breakpoints in the program's code.

As we saw in an Example for the ENTER command, the '=address' option is used to tell DEBUG where to start executing code. If you use 'g' all by itself, execution will begin at whatever location is pointed to by the CS:IP registers.

Breakpoints are used to HALT the execution of a program we're testing at some point of interest before its termination. Up to 10, optional breakpoint addresses may be set by simply listing them on the '-g' command line; separated by spaces. DEBUG will halt execution just before any of breakpoint addresses is about to be executed, and all of them will be 'cleared' at this time as well. (If you should somehow attempt to set more than 10 breakpoints, DEBUG will respond with: bp Error.

NOTE: Breakpoints can only be set at an address containing the first byte of a valid 8088/8086 opcode. So don't be surprised if picking some arbitrary address never halts the program; especially if you're trying to DEBUG a program containing opcodes DEBUG can't understand (that's any instruction which requires a CPU above an 8088/8086)!

Using "Go" after setting breakpoints at instructions you're sure DEBUG understands is one way you can get more use out of this program; for example, when debugging the "real" code of a Master Boot Record written for an 80386 or above processor. DEBUG won't be able to disassemble, nor step through, such code, but it can pass the code for those type of instructions to the CPU for immediate execution, and still stop at the breakpoint(s) you've set for any instruction that it does understand!

CAUTION: DEBUG replaces the original instructions of any listed breakpoint addresses with CCh (an INT 3). The instructions at these locations are restored to their original bytes ONLY if one of the breakpoints is encountered. If DEBUG does not halt on any of the set breakpoint(s), they will remain enabled! So, don't ever save the code unless you're sure all breakpoints have been cleared! (Saving your work to a backup copy before ever using a breakpoint is the best way to avoid corrupting the code.)

Technical Notes: The "User" stack pointer must be valid and have 6 bytes available for this command to function correctly. An iret instruction is used to jump to the first breakpoint encountered. DEBUG sets the User Stack Pointer and pushes the user Flags, the Code Segment register and the Instruction Pointer onto the User Stack. So if the User Stack is not valid or is too small, the operation might crash.

Back to TOC

Assemble:  A  [address]

Creates machine executable code in memory beginning at CS:0100 (or the specified address) from the 8086/8088 (and 8087) Assembly Language instructions which are entered. Although no Macro instructions nor labels are recognized, you can use the pseudo-instructions 'DB' and 'DW' (so you can use the DB opcode to enter ASCII data like this: DB 'This is a string',0D,0A ); spaces after the commas would make it clearer but aren't necessary.

The 'A' command remembers the last location where any data was assembled, so successive 'A' commands (when no address is specified) will always begin at the next address in the chain of assembled instructions. This aspect of the command is similar to the Dump command which remembers the location of its last dump (if no new address is specified).

The assembly process will stop after you ENTER an empty line.

Examples:

Using the character string from our E (Enter) command above:

      -a 200
      xxxx:0200 db 'An "ASCII-Z string" is always followed by '
      xxxx:022A db "a zero-byte ('00h').", 0
      xxxx:023F
      -d 200 23e
      xxxx:0200  41 6E 20 22 41 53 43 49-49 2D 5A 20 73 74 72 69   An "ASCII-Z stri
      xxxx:0210  6E 67 22 20 69 73 20 61-6C 77 61 79 73 20 66 6F   ng" is always fo
      xxxx:0220  6C 6C 6F 77 65 64 20 62-79 20 61 20 7A 65 72 6F   llowed by a zero
      xxxx:0230  2D 62 79 74 65 20 28 27-30 30 68 27 29 2E 00      -byte ('00h')..

ENTER the characters in bold blue type; you do not need to enter the comments after the semi-colon ( ; ) symbols:

      -a 100
      xxxx:0100 jmp 126      ; Jump over data that follows:
      xxxx:0102 db 0d,0a,"This is my first DEBUG program!"
      xxxx:0123 db 0d,0a,"$"
      xxxx:0126 mov ah,9     ; Function 09 of Int 21h:
      xxxx:0128 mov dx,102   ; DS:DX -> $-terminated string.
      xxxx:012B int 21       ; Write String to STD Output.
      xxxx:012D mov ah,0     ; Function 00 of Int 21h:
      xxxx:012F int 21       ; Terminate Program.
      xxxx:0131
      -g =100

      This is my first DEBUG program!

      Program terminated normally
      -

NOTE: You can pipe simple 8086/8088 Assembly Language "scripts" into DEBUG (You can even include a semi-colon ';' followed by comments on most of its lines. For some odd reason though, these comments do not appear to be allowed on DB/DW lines!). For example, you can copy and paste the following into DEBUG (after entering an initial "a" command) and obtain the same results as above:

jmp 126      ; Jump over data that follows:
db  0d,0a,"This is my first DEBUG program!"
db  0d,0a,"$"
; End of string marker above: "$"=24h
mov ah,9     ; Function 09 of Int 21h:
mov dx,102   ; DS:DX -> $-terminated string.
int 21       ; Write String to STD Output.
mov ah,0     ; Function 00 of Int 21h:
int 21       ; Terminate Program.
  • DEBUG uses the convention of enclosing operands which refer to Memory locations in square brackets '[ ]' (as opposed to an immediate value as an operand).

  • DEBUG may require you to explicitly tell it whether or not an operand refers to a word or byte in Memory! In such cases, the data type must be stated using the prefixes 'WORD PTR' or 'BYTE PTR'

  • For all 8087 Math Coprocessor opcodes, the WAIT or FWAIT prefix must be explicitly specified.

Back to TOC

Unassemble:  U  [range]
Disassembles machine instructions into 8086 Assembly code. Without the optional [range], it uses Offset 100 as its starting point, disassembles about 32 bytes and then remembers the next byte it should start with if the command is used again. ( The word 'about' was used above, because it may be necessary to finish with an odd-number of bytes greater than 32, depending upon the last type of instruction DEBUG has to disassemble. )

NOTE: The user must decide whether the bytes that DEBUG disassembles are all 8086 instructions, just data or any newer x86 instructions (those for the 80286, 80386 on up to the lastest CPU from Intel; which are all beyond the ability of DEBUG to understand)!
   Example:

   -u 126 12F
   xxxx:0126 B409          MOV     AH,09
   xxxx:0128 BA0201        MOV     DX,0102
   xxxx:012B CD21          INT     21
   xxxx:012D B400          MOV     AH,00
   xxxx:012F CD21          INT     21
   -

Back to TOC

  Input:  I  port

The use of I/O commands while running Windows™9x/Me is just plain unreliable! This is especially true when trying to directly access hard disks! Under Win NT/2000/XP, the I/O commands are only an emulation; so don't trust them. Though the example below still works under Win2000/XP, it's most likely using some WinAPI code to show what's in the Windows clock area; not directly from an RTC chip.

Long ago (when DOS was the only OS for PCs), there were dozens of BASIC programs that used I/O commands for handling tasks through parallel and serial ports (e.g., to change the font used by a printer or values in a modem's control registers). Under real DOS, they can still be used for direct communications with keyboards or a floppy drive's control chips along with many other hardware devices.
Here's an example of how to read the hours and minutes from a computer's "real time clock" (RTC):

    -o 70 04  <-- Check the hours.
    -i 71
    18  <----- 18 hours (or 6 p.m.)
    -o 70 02  <-- Check the minutes.
    -i 71
    52  <----- 52 minutes
The first space isn't necessary under most versions of DEBUG; so you can try to get away with just "o70" and "i71" instead. Here's a page of more complex examples dealing with hard drives and the ATA commands for reading info directly from a disk controller!
Back to TOC

  Output:  O  port  byte

See comments under theInput command.

Back to TOC

   Load:
L [address] [drive] [firstsector] [number]
   or program! (See the N command for more on this)

This command will LOAD the selected number of sectors from any disk's Logical Drive under the control of MS-DOS or Windows into Memory. The address is the location in Memory the data will be copied to (use only 4 hex digits to keep it within the memory allocated to DEBUG), the drive number is mapped as: 0=A:, 1=B:, 2=C:, etc., firstsector counts from ZERO to the largest sector in the volume and finally number specifies in hexadecimal thetotal number of sectors that will be copied into Memory (so a floppy disk with 0 through 2,879 sectors would be: 0 through B3F in Hex).

The terms 'Volume' or 'Logical Drive' used in the definition above mean you cannot use the 'L' command to load or examine the MBR, or any other sectors outside the Primary Volumes or Logical Drive Letters assigned by DOS or Windows! For example (under Windows™ 9x/ME), if you enter the command: L 100 2 0 1 in DEBUG, instead of seeing the very first sector on that hard disk (the MBR), you'll see the first sector of the Boot Record for the Logical drive C: instead (the first partition that can accessed by a compatible MS-DOS or Windows OS). This and the following comments about diskettes, show that DEBUG has always been quite limited compared to a good disk editor or the UNIX 'dd' program.

Load can still be useful in examining Floppy Disks even under Windows™ 2000/XP, but (unfortunately), only if the disk can be read by MS-DOS or Windows. Once again, this shows how limited DEBUG is compared to any utility that can view the raw data on either a hard drive or diskette. (For those of you who wish to examine the actual contents of a hard disk under Windows™ XP, there are free disk editors, such as HxD, which allow you to do so.)

Unlike hard disks, the very first sector on a floppy disk is an OS Boot sector. Here's what you might see from a Logical disk sector and some d umps from a couple floppy disks.

Examples:

-l 100 2 0 1   [ the C: drive. ]
-d 100 10f
xxxx:0100  EB 58 90 4D 53 57 49 4E-34 2E 31 00 02 08 20 00  .X.MSWIN4.1... .
-d 280 2ff
xxxx:0280  01 27 0D 0A 49 6E 76 61-6C 69 64 20 73 79 73 74  .'..Invalid syst
xxxx:0290  65 6D 20 64 69 73 6B FF-0D 0A 44 69 73 6B 20 49  em disk...Disk I
xxxx:02A0  2F 4F 20 65 72 72 6F 72-FF 0D 0A 52 65 70 6C 61  /O error...Repla
xxxx:02B0  63 65 20 74 68 65 20 64-69 73 6B 2C 20 61 6E 64  ce the disk, and
xxxx:02C0  20 74 68 65 6E 20 70 72-65 73 73 20 61 6E 79 20  then press any
xxxx:02D0  6B 65 79 0D 0A 00 00 00-49 4F 20 20 20 20 20 20  key.....IO
xxxx:02E0  53 59 53 4D 53 44 4F 53-20 20 20 53 59 53 7E 01  SYSMSDOS   SYS~.
xxxx:02F0  00 57 49 4E 42 4F 4F 54-20 53 59 53 00 00 55 AA  .WINBOOT SYS..U.
-
-l 100 0 0 1   [ a floppy in the A: drive. ]
-d 100 13d
xxxx:0100  EB 3C 90 29 47 38 71 33-49 48 43 00 02 01 01 00  .<.)G8q3IHC.....
xxxx:0110  02 E0 00 40 0B F0 09 00-12 00 02 00 00 00 00 00  ...@............
xxxx:0120  00 00 00 00 00 00 29 40-16 D8 13 4E 4F 20 4E 41  ......)@...NO NA
xxxx:0130  4D 45 20 20 20 20 46 41-54 31 32 20 20 20        ME    FAT12
-
-l 100 0 0 1   [ a different floppy in the A: drive. ]
-d 100 13d
xxxx:0100  EB 3C 90 53 59 53 4C 49-4E 55 58 00 02 01 01 00  .<.SYSLINUX.....
xxxx:0110  02 E0 00 40 0B F0 09 00-12 00 02 00 00 00 00 00  ...@............
xxxx:0120  00 00 00 00 00 00 29 7E-CF 55 3C 20 20 20 20 20  ......)~.U<
xxxx:0130  20 20 20 20 20 20 46 41-54 31 32 20 20 20              FAT12
-
-d 2d0 2ff
xxxx:02D0  42 3B 16 1A 7C 72 03 40-31 D2 29 F1 EB A7 42 6F  B;..|r.@1.)...Bo
xxxx:02E0  6F 74 20 66 61 69 6C 65-64 0D 0A 00 00 00 00 4C  ot failed......L
xxxx:02F0  44 4C 49 4E 55 58 20 53-59 53 F4 3C 82 3A 55 AA  DLINUX SYS.<.:U.

The Linux Boot disk above (note the word: SYSLINUX) is the kind formatted as an MS-DOS diskette and not with a true Linux file system (such as ext2 or ext3). If it had been formatted with some other kind of file system, or had a faulty boot sector, then MS-DEBUG would not be able to read it! Instead you'd see that old "General failure reading drive A / Abort, Retry, Fail?" error message! And when you had finally cleared away that error message, you'd be greeted by DEBUG's "Disk error reading drive A" error message. This makes DEBUG almost worthless as far as trying to fix an error in a floppy disk's boot sector! However, if you keep a binary copy of a good floppy disk Boot Sector somewhere, you could use DEBUG to overwrite whatever's on a faulty floppy disk's first sector (see Write command). But if you really need to see what's in such a Boot sector (i.e., what is keeping DEBUG from recognizing it as valid), you'll need to use a disk editor such as Symantec's Norton DiskEdit (in Physical disk Mode only).

NOTE: Just because a floppy disk can't be read by DOS or opened in DEBUG does NOT necessarily mean it's defective. It might simply have been formatted with a file system it cannot recognize (such as Linux's ext2) and could easily boot-up on its own; a very good reason for labeling your disks! (CAUTION: Never try booting your system with a disk you're not 100% sure of; unless you disconnect all hard disks and don't have any flash BIOS, since it might contain a nasty boot virus! )
[ Many floppy disks have the letters IHC in their OEM ID field. What kind of OEM Name is that? None. Someone at Microsoft decided that this was where they'd place a new pseudo-random type of identification to make sure that any information cached by 'Windows 9x' from one disk wouldn't be mixed up with info from a different one if you swapped disks. The whole string begins with five pseudo-random hex bytes, and always ends with the characters IHC. All floppy diskettes that are not write-protected will have any original OEM ID overwritten. Once Windows has written this string, it will remain the same for any future disk reads or writes. However, performing even a quick format under Windows, will change the five hex bytes every time.
Some have concluded the characters 'IHC' are the first three letters of the word "Chicago" in reverse order, since Chicago was the 'code name' for Windows™ 95 before it was ever released (it would have appeared as ' OGACIHC' on the hypothetical disk). Although certainly a possibility, I have no proof of that. Due to our interest in some very old Greek Manuscripts, we still can't help but see the 3 characters 'IHC' as an Iota, Eta and old style Sigma since this combination of letters was often used as an abbreviation for the Greek word "IHSUS" (Jesus). Just another of many coincidences in our lives.
REMEMBER: If you really want to preserve all of the contents of an important diskette, you can't even perform a simple Directory read under a Windows OS, UNLESS it is 'write-protected' and you know the drive's write-protect system is functioning correctly! ]

Back to TOC

   Move:  M  range  address
This command could be called COPY (not Move), since it only copies all the bytes from within the specified range to a new address.

Examples:
  1)   -m 7c00 7dff 600
Copies all 512 (200h) of the bytes between Offsets 7C00 and 7DFF (inclusive) to Offset 0600 and following.
  2)   -m 100 2ff 200

This second example shows it's very easy to overwrite much of the same source area you're copying from when using the Move command. However, DEBUG must store all the source bytes in Memory before writing them; otherwise, this example would cause a problem when overwriting an area it hadn't copied data from yet, if it were copying only one byte at a time from that source area! The example above copies all 512 bytes of offsets 100h through 2FFh (inclusive) to Offsets 0200h and following; overwriting the last 256 (2FF-200+1 hex) bytes of the source in the process. This is also true under real 16-bit DOS.

Note: If your Move command produces a situation where offset FFFFh has already been written to yet there's still more data to write, you may experience unexpected results! Remember, DEBUG is technically assigned to only one 64 KiB Segment. So, the data will wrap around to the beginning of the Segment, possibly overwriting some of the source bytes you told it to copy from! But other symptoms may occur as well, since the first area to be overwritten after wrapping around (00h through FFh) is sometimes used by DEBUG to keep track of itself. So do the math whenever copying bytes to a higher location in Memory, to be sure you don't run out of room at the end of the Segment.

Copying bytes to a lower location in the Segment is quite simple though; DEBUG could actually copy just one byte at a time in that direction and never overwrite a source byte before it was already copied.

Back to TOC

   Name:  N  [pathname]  [arglist]

This command can be used to load files into DEBUG's Memory after you have started the program, but it's main function is to create a new file under control of the Operating System which DEBUG can WRITE data to.
Normally, when you want to 'debug' a file, you'd start DEBUG with a command like this: C:\WINDOWS>debug test.com . But it's also possible to load a file into DEBUG's Memory from within DEBUG itself by using the 'N' command and then the 'L' command (with no parameters) like this:
    -n c:\temp\test.com
    -l
which will load the file test.com into DEBUG's Memory starting at location CS:0100 (you cannot specify any other location when using the L command like this!).

The 'N' command makes it quite easy to save data or an Assembly program created in DEBUG to a file on your hard drive! For example, the following commands (shown in bold blue type) will create a 68-byte file called DOSWINOK.COM in the C:\TEMP folder; even when running DEBUG in a DOS-window. The file names, however, are still limited to DOS's eight characters plus three for the extension (often called an 8.3 filename):

  -n c:\temp\doswinok.com
  -a 100
  cs:0100 jmp 138
  cs:0102 db 0d,0a,"It's OK to run this "
  cs:0118 db "program under DOS or Windows!"
  cs:0135 db 0d,0a,24
  cs:0138 mov dx,102
  cs:013B mov ah,9
  cs:013D int 21
  cs:013F mov ax,4c01
  cs:0142 int 21
  cs:0144   [Press ENTER key.]
  -rcx
  CX 0000
  :44
  -w
  Writing 00044 bytes   [ 68 bytes in decimal ]
  -q

How did we arrive at the value of "44" to put into the CX register for writing that many bytes to our new file? Well, if you assemble a program in DEBUG using the Assemble command just as we did above, you can subtract the location that we started our programming on from the location DEBUG displays on the line you stopped the assembly by pressing the ENTER key. This will save you a bit of thought by not having to remember when you subtract the first byte location (of the first instruction) from the last byte location (of the last instruction), both bytes being inclusive, that you must then add a 1 to the result to obtain the total number of bytes in your program. Or, putting this in terms of the digits involved: (144h - 100h ) = (143h - 100h + 1) = 44 hex = 68 decimal.

NOTE: Unlike other programs listed on this page, this last one used the Function 4Ch instead of Function 00 of Interrupt 21h to terminate its execution. This is the preferred termination function for most DOS programs, because it can send a "Return Code" (an ERRORLEVEL value; of whatever is in the AL register), and will also close all open files and free all memory belonging to the process. However, when you use this function to terminate a program you run under DEBUG, it has a tendency to terminate DEBUG itself; thus the reason we rarely use it here!

Homework: Follow the steps above to Assemble and save this program under DEBUG, then use DEBUG to debug it! Use the P(roceed) command to step through most of the instructions, since this will keep you from accidentally stepping into an INT(errupt) instruction! If you ever do use the T(race) command on an INT, you'll end up inside nests of BIOS routines which often crashes DEBUG!

Back to TOC

Register:  R  [register]
Entering ' r ' all by itself will display all of the 8086 register's contents and the next instruction which the IP register points to in both machine code and an unassembled (Assembly Language) form. For example, if you start DEBUG in a Windows 95B DOS-box with the command line:
>debug c:\windows\command\choice.com
 and then enter an ' r ' at the first DEBUG prompt, DEBUG will display someting similar to this:
AX=0000  BX=0000  CX=1437  DX=0000  SP=FFFE  BP=0000  SI=0000  DI=0000
DS=0ED8  ES=0ED8  SS=0ED8  CS=0ED8  IP=0100   NV UP EI PL NZ NA PO NC
0ED8:0100 E90E01        JMP     0211
For an explanation of the names of the registers (AX, BX, CX, etc. and the Flag symbols: NV UP EI PL NZ NA PO NC), see the Appendix (The 8086 CPU Registers). The last line shows the next CPU instruction (actually the first in this case) to be executed, begins at memory location 100 hex (the offset) in Segment ED8 hex (0ED8:0100) and the Hex bytes E90E01 represent the actual binary machine code of the CPU instruction (JMP 0211 in Assembly language) that would be executed by DEBUG if you entered a Trace (t) or Proceed (p) command.

If you enter the ' r ' followed by the abbreviation for an 8086 register, such as: ' rcx ', then DEBUG will display only the contents of that register followed by a line with a colon symbol (:) on which you can enter a hex number to change the contents of that register. If you simply press the ENTER key, the contents remain the same. For example:

    -rcx
    CX 0100
    :273
    -

means the Register command was used to change the contents of the CX register from 0100 to 0273. The command rcx could also be used again to verify the change had indeed taken place.

NOTE: The register command only functions with 16-bit registers; including the Flags register, so entering an 8-bit or an invalid register name results in: br Error.

Typing the letter f (for Flags) after the r: rf, causes DEBUG to display all the FLAG register bits and its 'prompt' on the same line. This prompt allows you to change all, or none, of the individual flag bits. For example, here's how you would display the flags and change only the Zero and Carry flag bits from being cleared (a 0 bit) to being set (a 1 bit) and check them without making any further changes:

   -rf
   NV UP EI PL NZ NA PO NC  -zr cy
   -rf
   NV UP EI PL ZR NA PO CY  -
   -
As you can see above the Zero and Carry flags were changed from NZ and NC (both cleared) to ZR and CY (both set). See our Appendix: The FLAGS Register for an explanation of all the Flag abbreviations.

Any order, with or without spaces, is acceptable after the 'prompt' (such as: -zrupcy).
  • Attempting to enter an incorrect abbreviation for a flag value (even with one or more correct names) results in a: bf Error and no flags are changed.
  • Attempting to enter abbreviations for both clearing and setting the same flag, at the same prompt, will cause DEBUG to display the: df Error.
Back to TOC

   Trace:  T  [=address]  [number]
The T command is used to trace (step through) CPU instructions one at a time. If you enter the T command by itself, it will normally step through only ONE instruction beginning at the location specified by your CS:IP registers, halt program execution and then display all the CPU registers plus an unassembled version of the next instruction to be executed; this is the 'default' mode of the TRACE command. Say, however, you wanted DEBUG to trace and execute seven instructions beginning at address CS:0205; to do so, you would enter:

    -t =205 7

Remember that the value for the number of instructions to execute must be given in hexadecimal just as all other values used in DEUBG. (Since the T command uses the "hardware trace mode" of the CPU, it's possible to step through instructions in a ROM - Read Only Memory - chip; or step into BIOS code which has been shadowed in read-only portions of Memory for decades now.) NOTE: If you find yourself stuck inside a long LOOP or REPeat string instruction, enter a P (Proceed) command and it will complete the operation and move to the next instruction.

Back to TOC

 Proceed:  P  [=address]  [number]
Proceed acts exactly the same as Debug's T (Trace) command for most instruction types; with these notable exceptions: Proceed will immediately execute all instructions (rather than stepping through each one) inside any subroutine CALL, LOOP, REPeat string instruction or any software INTerrupt. You can still step into an INT or execute all the code contained in a subroutine if you need to, but with the Proceed (P) command you are not required to do so.
This means Proceed will probably be the command of choice for most of debugging tasks, with Trace only being used to step through an unfamiliar subroutine or check the logic of the first few iterations of long REP string instructions or LOOPs. And it's a must use command when it comes to Interrupts!
Back to TOC

Write:
W [address] [drive] [firstsector] [number]
W A R N I N G
Do NOT experiment with the W - write command in DEBUG. It can be used effectively to create new files on your hard drive, but only if you use it properly. Trying to write directly to a sector on a hard disk would very RARELY be considered proper use of this command!
    Trying to write directly to a hard disk using sector numbers will most likely result in loss of data or even a non-booting system! (Although Windows XP and later prevent direct Sector writes to a hard disk, they are still allowed to floppy drive media, i.e., drive letters A: or B:)
The WRITE (W) command is often used to save a program to your hard disk from within DEBUG. But the only safe way to do so, especially under Windows, is by allowing the OS to decide where to physically create that file on the disk. This is done by first using the Name (N) command to set up an optional path and filename for the new file (or to overwrite one that already exists). DEBUG will automatically begin saving program or data bytes from Offset 0100 of the 64 KiB Segment the OS allocated for it. The only other requirement is to set the size of the file you wish to write by placing the total number of bytes in the combined BX and CX registers* before executing the WRITE command. The Register command is used to change the value in the CX register in the following example from our MyMBR Batch/Debug Script Program.

EXAMPLE:
After creating and running a small program inside of DEBUG which copies the Master Boot Record (MBR) to Offset 0000h through 01FFh, these DEBUG commands save the MBR to a file on the hard disk:
   -n mymbr.bin
   -rcx
   CX 0001
   :200
   -w 0
   Writing 00200 bytes   [ 512 bytes in decimal ]
   -

The BX register had already been set to zero by a previous instruction, so the CX register was simply set to 200 and the WRITE command executed with an address of 0 (if no address is used, the Write command starts saving bytes at Offset 100).

The WRITE command can, however, be used in a relatively safe manner with Floppy disks. For example, you could use the Load (L) command:
    l 7c00 0 0 1
to load the first sector of an MS-DOS or Windows floppy disk into DEBUG's memory at location 7C00, change some of the code and/or messages (if you know how to do so) and then use the 'W' command:
    w 7c00 0 0 1
to write the changes back to the floppy disk's first sector.

___________________
*Although the BX and CX registers are often referenced in books on Assembly as BX:CX when they discuss this write command, note that these registers are not being used like Segment:Offset pairs in this case! They are a true combination of higher and lower bytes which form a 'double word' for a theoretical total of about 4 GB (FFFF FFFFh = 4,294,967,295 bytes) that could be written to a file! Whether or not this is true of all versions of DEBUG, under DOS 7.1, we've been able to load image files of several hundred KiB and write the whole file to a new location!
For example, if you load a 360 KiB image file into DEBUG at a DOS prompt, then check the registers, BX will equal 0005 and CX will contain A000. The major problem here though is the fact DEBUG uses CONVENTIONAL MEMORY, so trying to load a file greater than about 400 KiB is bound to elicit an "Insufficient Memory" error!
[ click here to go back to text above ]

Back to TOC

N O T E :
You may have missed this page on: The Windows™ DOS Stub Program. And there are more examples of many DEBUG commands on these x86 tutorial pages:
FIRE.com: Some MS-DEBUG Tricks and The EICAR Standard AV Test Program .

Updated: September 28, 2007. (28.09.2007)
Previous Update: August 23, 2010. (23.08.2010)
Last Update: September 19, 2010. (19.09.2010)


Notes sur le langage C

Sponsoring website: Emergency Boot CD

A Guide to DEBUG
( The Microsoft® DEBUG.EXE Program )
Copyright©2004,2007,2009 by Daniel B. Sedory

This page may be freely copied for PERSONAL use ONLY !
( It may NOT be used for ANY other purpose unless you have
first contacted and received permission from the author ! )

  • A History of DEBUG
    • Beginnings
    • Changes in DEBUG
    • Under Windows™ 9x/Me
    • Under Windows™ NT/2000/XP and later
    • Summary

  • The Limitations of DEBUG
    • Important Initialization Values for DEBUG
    • Using DEBUG with .EXE Files

  • Special Memory Locations in MS-DEBUG

  • DEBUG's own Dynamic Stack Area

  • Have you found a 'bug' in DEBUG?

  • Important Notes for using DEBUG

  • All the Commands -- Listed Alphabetically
    • Quick Links to Command Help

    PAGE TWO:
  • How to Use the COMMANDS
    • Meaning of Command Parameters

    • Detailed Help on each Command (begins here)
      • An Example Program for you to Enter, Run and Edit under DEBUG.
      • A Note about Win 9x's 'IHC' string in Diskette Boot Sectors

  • Appendix
    • The 8086 CPU Registers
    • The FLAGS Register
    • The Segment:Offset Addressing method used by DEBUG

A History of MS-DEBUG

Beginnings

In 1980, Tim Paterson began working on a 16-bit OS for the 8086 S-100 Bus card he had designed for SCP (Seattle Computer Products) the previous year. To help in getting QDOS (later called 86-DOS) to work correctly, Tim created a debugger in a ROM chip; the code for that ROM version was released into the Public Domain. Later, Tim adapted the code to run as a .COM program under QDOS, and also added the ability to disassemble 8086 machine code. In the meantime, Microsoft® had been busy purchasing the rights to sell Tim's QDOS to IBM® for their 'secret' PC project. Tim was then hired by Microsoft as the primary author of their first OS. When he completed his work on IBM's Personal Computer™ DOS 1.00 in 1981, his DEBUG.COM utility was included with it. All the functionality that Tim put into DEBUG is still there and little has been added to it (the major exception being the Assemble command; added under DOS 2.0).
[ Thanks go to Tim Paterson himself for reviewing this perspective on DEBUG's beginnings. ]

Changes in MS-DEBUG

With the release of DOS 2.0, DEBUG gained the ability to assemble instructions directly into machine code (the A command). This is one of the most important commands for many of its users. Though lacking much of the functionality of a stand-alone Assembler, e.g., all Jumps must be to hexadecimal addresses (no labels can be used), many useful .COM programs have been assembled with this command. Under DOS 3.0, the P (Proceed) command was added, so DEBUG could quickly execute subroutines; at the same time, it became possible to attempt stepping through Interrupts with the T (Trace) command. When DOS made EMS (Expanded Memory) functions available under DOS 4.0, the four commands xa, xd, xm and xs were also added to DEBUG. It appears they were rarely, if ever used though, even by programmers. For most of us, the only noticeable change in DEBUG was the addition of the help command (type a '?' while inside DEBUG) under DOS 5.0; when all DOS commands finally got the /? command-line switch.

DEBUG's code went through a number of changes (and 'bug fixes' too) over the years! Some of these internal changes were related to DOS system calls and screen output, then there was the change in file type from a .COM to an .EXE program under DOS 5.0. But in spite of all those changes and others which followed, DEBUG has never had an official revision since 2.40 (those digits have been embedded inside all versions of DEBUG since DOS 3.0). We can only guess about the real reasons that Microsoft® never updated DEBUG to handle instructions beyond those of the Intel® 8086/8087/8088 processors. Microsoft® did create their own Assembler (MASM), 'C' compiler and Debugger (CodeView ); which you could use too, if you were willing to pay extra, so that could have been one of their reasons. Rather than using MASM and CodeView, many opted for the less expensive Borland® assembler (TASM) and Turbo™ Debugger when they appeared, or some other commercial product. However, users and students alike can still learn a great deal about Assembly language by using DEBUG.

DEBUG under Windows® 9x/Me

The internal structure of these Windows® versions of DEBUG appear much different than any previous DOS forms; at least at first glance. Though it seems a great deal has changed, you'll still find the phrase "Vers 2.40" but in a different location. Windows® itself went through a lot of changes during this period, such as being able to handle a new file system, FAT32, and larger drives. But without access to its source code, we can't be sure if there were any major differences in DEBUG. The changes might be due to something as simple as just reorganizing the error messages in the source code and/or using a new Assembler/Linker.

DEBUG had always been an effective tool in the hands of any Batch programmer, but some time after the introduction of Windows™ 95 and especially with Windows™ 98, that effectiveness was diminished when its I/O commands became unreliable! Whether due to a 'bug' in DEBUG itself or in Windows®, the fact is that I/O commands under Windows™ 9x/Me cannot be relied upon for direct access to a hard drive! If you run our ATA drive ID script under Win9x/Me, the data you get back is as interesting as it is disturbing: It appears that every other byte is still correct! So, one has to wonder what the cause of this problem might be.

DEBUG under Windows® NT/2000/XP/2003

The DEBUG program included with Windows® NT/2000/XP/2003 appears to operate the same as it did under DOS 5.0, but with two major exceptions:

DEBUG is no longer allowed to load from or write to any logical HDD sectors; only named files can still be read from or written to under an NT-type OS. It can, however, still access diskette sectors in the A:\ or B:\ drives with the L and W commands, but only if those diskettes contain a file system the host OS (2000, XP, 2003) can recognize!
(See the L command in the Tutorial section for more information.)

[ Note: DEBUG has never been able to directly access areas of an HDD outside of its drive volumes; such as an Extended partition table or even the MBR sector! However, DEBUG can be used to access such data by programming it to run INT13 commands or using a script file under DOS (e.g., our old CopyMBR script). Note again, that no Windows version after Win98/ME will allow INT13 access! ]

2) The I and O commands are essentially useless, since the program's interface with the rest of the system is only being emulated under these versions of Windows® rather than having any direct access to the hardware. This was already true to varying degrees under previous versions of Windows®.

This may surprise you: We purposely mentioned the DOS 5.0 version of DEBUG here, since the DEBUG.EXE file included with Windows® XP (and every other version of the NT OS series) is exactly the same program file created for MS-DOS 5.0 (md5sum = c17afa0aad78c621f818dd6729572c48). DEBUG was only one of a small handful of DOS 5.0 programs that didn't require any changes to run under an NT operating system. It's almost ironic that another of those few programs is EDLIN, a line editor disliked by most DOS users. Though EDLIN was also created by Tim Paterson, he did so in just two weeks and was shocked when he heard IBM had actually included it in their PC-DOS 1.00 release! No doubt he wished it had been replaced by something better way back in 1981. It wasn't until the release of DOS 5.0, that EDLIN was effectively replaced by Microsoft's EDIT.COM program (v 1.0, 1991. Note: This first version of EDIT required QBASIC to also be present); EDLIN was, however, still retained, to be 'backwards compatible' with various 3rd-party Batch files. Though NOTEPAD or more advanced editors are available under Windows™, you can still use the 1995 standalone version of EDIT (v 2.0.026) at Command Line prompts in Windows™ XP; its menus will even respond to mouse clicks.

Summary

Though created at the beginning of the 16-bit processor era (before the 80286 existed), more recent versions of DEBUG (such as those found inside a Windows™ Me or 98SE Emergency Boot Diskette's EBD.CAB file) are still useful to PC techs for direct access to certain memory locations on present-day systems (an Intel® Pentium™ IV, for example). DEBUG can also be quite useful for educational purposes. And even for debugging the Assembly code that is required during the boot process: The software that checks the Partition Table on hard disks and loads OS Boot Sectors into Memory. Unfortunately, many Boot Managers and recent MBR sectors now use instructions requiring a 386 (or even 486) class CPU to function, making it difficult to use DEBUG for such a purpose. Because of the backward compatibility of most Intel® processors, and the fact that it was included with Microsoft® Windows™ XP and 2003, DEBUG has had a much longer life span than ever expected. Though the ITANIUM™ CPU was not x86-compatible, the AMD64 was. In 2005, Intel® made the so-called "x64-based" CPUs that were once again x86-compatible. So, DEBUG still continues to find some use on 64-bit computers, even my new Intel®Core™ 2 Quad (4 processors in one) machine.

The Limitations of MS-DEBUG

DEBUG was originally designed to work with .COM programs having a maximum size of only 65,280 bytes [ (64 x 1024) - 256 ] or less; how much less, depended upon the maximum number of bytes the program had to place on the Stack at the same time. The subtraction of 256 bytes is necessary since DEBUG often uses the area from offset 00 through FF hex for some internal data such as the name of the file that was loaded. Remember, true .COM programs by definition are supposed to fit inside a single Segment of memory (only 64 KiB).

Even when running MS-DEBUG under the latest Windows® OS, since it's still an old 16-bit DOS application, you can only open files whose names have been saved in the 8.3 DOS convention; i.e., up to 11 characters total, using no more than 8 DOS characters for the name and 3 for the extension.

As early as DOS 1.10, DEBUG was able to load files larger than 64 KiB. Basically, how large a file that DEBUG can safely use without error depends on the amount of available memory and the way the OS handles memory management. We'll say more about this below.

A. When DEBUG starts with no command-line parameters, it:

1) Allocates all 64 KiB of the first free Memory Segment.

2) The Segment registers, CS, DS, ES and SS are all set to the value of that 64 KiB Segment's location (CS=DS=ES=SS=Segment Location ).

3) The Instruction Pointer (IP) is set to cs:0100 and the Stack Pointer (SP) is set to ss:FFEE (under DOS 3.0 or above).

4) The registers, AX, BX, CX, DX, BP, SI and DI are cleared to zero along with the flag bits in the Flag Register; with one exception: The Interrupts Flag is set to Enable Interrupts. (See the Appendix, The 8086 CPU Registers for more information.)

B. When DEBUG starts with a filename (other than an .EXE), it:

1) Allocates at least 64 KiB of the first free Memory Segment for debugging programs or examining files specified on the command line. [Note: Ever since DOS version 1.10, DEBUG has had the ability to load (and save) files larger than 64 KiB. Just how large a file it can handle, depends upon both the OS and available memory. But before you ever consider using DEBUG to save some large file you want to edit, you should know the amount of memory it can use is limited to what's available in CONVENTIONAL MEMORY only! And remember that just because your system can debug a certain file, doesn't mean someone else's will be able to.]

2) The Segment registers, CS, DS, ES and SS are all set to the value of the first 64 KiB Segment's location (CS=DS=ES=SS=Segment Location); for a file that's larger than 64KiB, you'll have to set different segment values to access all the bytes loaded into memory beyond the first 64 KiB.

3) The Instruction Pointer (IP) is set to cs:0100 and the Stack Pointer (SP) is set to ss:FFFE (version 3.0+). [ Note: This is not the same as the ss:FFEE in A. 3) above; there's a 16 byte difference. ]

4) Most of the registers follow the same pattern as above, except for the CX and sometimes BX registers: The size of the file will be placed into the linear combination of the BX and CX registers; for files less than 64 KiB - 256 bytes, only CX is used. Example: If you can load a file of 360,247 bytes, then BX=0005 and CX=7F37 ( 57F37 hex = 360,247 ). If you load a file of exactly 65,536 bytes from a prompt, these registers will be: BX=0001, CX=0000. But due to the automatic 100h load offset, the file's last 256 bytes will have been loaded at the beginning of the next 64 KiB segment.

Remember: The Segment assigned to DEBUG, depends on the amount of memory in use, not the total memory available. So, the same DOS machine, whether it has 16 or even 4096 MiB of memory, will generally load DEBUG into the same Segment; unless a "terminate and stay resident" program is using that memory, or memory was not properly deallocated prior to running DEBUG.

Using DEBUG with .EXE Files

Any version of DEBUG from DOS 2.0 or higher, makes use of the operating system's EXEC function which means that it's possible for you to perform a limited amount of debugging on an .EXE program. However, DEBUG can never be used to save either an .EXE or a .HEX file to disk, since both of these file types contain extra data that DEBUG was never programmed to create after EXEC removed such data! It is quite possible though, to change the extension of an .EXE file, for example to .BIN, so DEBUG can be used to edit such a file, then change it back to an .EXE extension afterwards. Normally we'd recommend using a Hex editor instead, but would like to point out that DEBUG could be used with Batch files and scripts to carry out such edits automatically; taking the place of a Patch program.

One of the simplest .EXE programs you can run under DEBUG is the so-called DOS "Stub" found inside many Windows® executables. You can follow along as we examine one of these here!

Special Memory Locations in MS-DEBUG

There will always be some code and data placed within the first 256 bytes of the Segment for DEBUG's own use. And although DEBUG often functions as expected if you zero-out this area, there may be some cases where you wouldn't want to alter its contents. The code bytes are simple and always found in the same locations: The first two bytes of this area ("CD 20") are machine code for the DOS interrupt:INT 20. The bytes at offsets 50h and 51h ("CD 21") form anINT 21, and the byte "CB" at offset 52h is aRETF instruction.

When booting from an MS-DOS 6.22 upgrade install disk, this area will appear as follows (offsets 90h - FFh were all zero bytes):

A:\>debug
-d 0 8f
1787:0000  CD 20 C0 9F 00 9A EE FE-1D F0 4F 03 EB 11 8A 03   . ........O.....
1787:0010  EB 11 17 03 EB 11 38 0E-01 01 01 00 02 FF FF FF   ......8.........
1787:0020  FF FF FF FF FF FF FF FF-FF FF FF FF 5F 0F 4E 01   ............_.N.
1787:0030  AB 16 14 00 18 00 87 17-FF FF FF FF 00 00 00 00   ................
1787:0040  06 16 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1787:0050  CD 21 CB 00 00 00 00 00-00 00 00 00 00 20 20 20   .!...........
1787:0060  20 20 20 20 20 20 20 20-00 00 00 00 00 20 20 20           .....
1787:0070  20 20 20 20 20 20 20 20-00 00 00 00 00 00 00 00           ........
1787:0080  00 0D 75 73 0D 0D 00 00-00 00 00 00 00 00 00 00   ..us............

When running DEBUG without a filename, whatever appeared on the previous command line, except for the command itself, will be displayed in the bytes at offsets 82h and following. These are often referred to as DOS switches or parameters. Thus, the "us" in the display above was from the command "keyb us" in the DOS 6.22 install disk's AUTOEXEC.BAT file. And if we had run the command "dir /w" before executing DEBUG, a "/w" would have appeared here instead. Note: Successive uses of DOS parameters are never cleared from memory, only overwritten. So, many characters of a very long parameter string will often remain intact, and as a consequence, will be copied to the bytes at offsets 82h through FFh each time DEBUG is run.

One of these data locations (the Word at offsets 36h - 37h) clearly saves the Segment assigned to DEBUG for our use. However, if we go on to load the file edit.com and dump the beginning of the Segment again, we'll find the Segment value itself has changed from 1787h to 1798h (a difference of 11h or 17 paragraphs, amounting to 256 + 16 = 272 bytes):

-n edit.com
-l
-d 0 8f
1798:0000  CD 20 C0 9F 00 9A F0 FE-1D F0 4F 03 EB 11 8A 03   . ........O.....
1798:0010  EB 11 17 03 EB 11 DA 11-01 01 01 00 02 FF FF FF   ................
1798:0020  FF FF FF FF FF FF FF FF-FF FF FF FF 75 0F E8 49   ............u..I
1798:0030  EB 11 14 00 18 00 98 17-FF FF FF FF 00 00 00 00   ................
1798:0040  06 16 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1798:0050  CD 21 CB 00 00 00 00 00-00 00 00 00 00 45 44 49   .!...........EDI
1798:0060  54 20 20 20 20 43 4F 4D-00 00 00 00 00 20 20 20   T    COM.....
1798:0070  20 20 20 20 20 20 20 20-00 00 00 00 00 00 00 00           ........
1798:0080  09 20 45 44 49 54 2E 43-4F 4D 0D 00 00 00 00 00   . EDIT.COM......

At first, we were unsure why DEBUG was doing this, but knew it had nothing to do with the size of this program, which is only 413 bytes. Instead it's simply because this is a "program" (EDIT.COM) rather than some other type of file. DEBUG did not do this when loading much larger files of other types, but did so again when loading any of the disk's *.EXE programs. We then confirmed a similar change when loading *.COM or *.EXE programs into DEBUG on an XP machine, but the change there was larger; it added up to 91 paragraphs! After more experiments, using the SET and PATH commands, we discovered DEBUG had some need to load a copy of the DOS "environment variables" between its initial "data area" and a new 256-byte data area it creates when debugging only DOS "program" files. Even when no PATH or environmental variables exist, DEBUG still needs to create a new "data area" for *.COM or *.EXE files.

When running DEBUG in a Windows® DOS-box (under CMD.exe), dumping its first 256 bytes will almost always show the same fragmented string (shown below in white text). The characters are the remains of the Ntvdm program (which starts as soon as any 16-bit command is run) quickly reading one line at a time from the file AUTOEXEC.NT (located in the C:\WINDOWS\system32 folder), into the same area of memory where command line parameters are stored. The longest line in that file, including its trailing 0Dh (carriage return) byte, is successively overwritten by shorter lines in the file until the process results in what's copied to offsets 82h through CEh of DEBUG's Segment:

C:\>debug
-d 0 cf
0B20:0000  CD 20 FF 9F 00 9A EE FE-1D F0 4F 03 84 05 8A 03   . ........O.....
0B20:0010  84 05 17 03 84 05 25 04-01 01 01 00 02 FF FF FF   ......%.........
0B20:0020  FF FF FF FF FF FF FF FF-FF FF FF FF 28 05 4E 01   ............(.N.
0B20:0030  44 0A 14 00 18 00 20 0B-FF FF FF FF 00 00 00 00   D..... .........
0B20:0040  05 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
0B20:0050  CD 21 CB 00 00 00 00 00-00 00 00 00 00 20 20 20   .!...........
0B20:0060  20 20 20 20 20 20 20 20-00 00 00 00 00 20 20 20           .....
0B20:0070  20 20 20 20 20 20 20 20-00 00 00 00 00 00 00 00           ........
0B20:0080  00 0D 20 20 20 53 45 54-20 42 4C 41 53 54 45 52   ..   SET BLASTER
0B20:0090  3D 41 30 0D 64 64 72 65-73 73 2E 20 20 46 6F 72   =A0.ddress.  For
0B20:00A0  20 65 78 61 6D 70 6C 65-3A 0D 20 6F 6E 20 4E 54    example:. on NT
0B20:00B0  56 44 4D 2C 20 73 70 65-63 69 66 79 20 61 6E 20   VDM, specify an
0B20:00C0  69 6E 76 61 6C 69 64 0D-20 6F 6E 6C 79 2E 0D 00   invalid. only...

None of the line feeds (0Ah) at the end of each line in AUTOEXEC.NT will ever appear here, because the carriage returns (0Dh) just preceding them send the cursor to the start of the line each time they're encountered, and whatever comes before the first space character (20h) in every line does not get copied; which is why the "REM" of the last three lines doesn't appear here either.

The byte at offset 81h is always 0Dh; even if the file AUTOEXEC.NT contains a single byte of any value.

Note: If you rename or delete AUTOEXEC.NT, you will not be allowed to run DEBUG (nor any other 16-bit program; all of which must run under Ntvdm). You can, however, save a copy of AUTOEXEC.NT, then edit it to see how your changes affect what's copied into DEBUG. You may reduce its size to just a single byte. But in order to see anything other than zero bytes in offsets 82h and following, at least one space byte (20h) must be placed between a non-space byte at the beginning of a line and whatever you'd like to have displayed. If the file contains only the 3 bytes: "T", space and "S", then offsets 82h and 83h would be an "S" followed by 0Dh.

DEBUG's "Dynamic Stack" Area

This section is presently a "Work in Progress", but if you happen to see this before it's finished, can you guess what it's about?

Have you found a "Bug" in DEBUG?

Although almost all the code used by programmers performs exactly as expected; once they've eliminated their own errors in logic that is, occasionally it will produce surprising results because they didn't dig deep enough into the fine print of the user manuals for a PC's processor. Professional programmers will always test their code in as many ways as reasonably possible, but studying the processor's programming notes; especially sections pertinent to any of their tasks, should be high on their list! NOTE: If you want to be a much better hacker, the example presented here might cause you to delve into Intel's detailed notes on how their CPUs handle various instructions.

Have you ever encountered two distinct lines of Assembly instructions that DEBUG always steps through without ever stopping at the second line? The following is just one of MANY repeatable examples we could list here. Open any instance of DEBUG (DOS or Windows; any version), and copy and paste the following E (Enter) command at its (-) prompt:

e 100 8C C8 8E D0 B0 74 90 90

After entering "u 100 107" it should disassemble to:

 xxxx:0100 8CC8    MOV   AX,CS  <- Keep Stack in CS Segment.
 xxxx:0102 8ED0    MOV   SS,AX  <- The key instruction!
 xxxx:0104 B074    MOV   AL,73  <- Could be almost anything.
 xxxx:0106 90      NOP
 xxxx:0107 90      NOP

Now enter an "r" at the prompt and try to single step (t) through the code. As soon as you enter the t command at offset 0102h, you'll wind up at offset 0106h; every time! Is this some "bug" that was never dealt with? The instruction at offsets 0104h ff. could be almost anything; any 1-, 2-, 3- or even 4-byte machine code will do; we purposely picked one that would alter a register's contents (AL in this case) so you could see this instruction had indeed been executed by the CPU; without the user ever having a choice to do so.

This effect will always be observed no matter what version of DEBUG you run it under; MS-DOS 7.1, 5.0 or all the way back to the first version of DEBUG under IBM PC DOS 1.0 (no guarantee it would act the same if you ran it on an original PC though; we only have an 80486 and later for testing). However, if you expand your research to include other debugging tools, you'll soon realize the chances of every version of two or more tools having the same "bug" are... well, way too coincidental. So, why does this code affect a debugger's interrupt abilities?

If you haven't already reached for your Intel® Instruction Set Reference... What's that? You don't have one! Well, you'd better search for the keywords: Intel, IA32, Software, Instruction and at least download a PDF digital copy of the Instruction Set Reference! (Usually found as two separate files titled: Volume 2A: Instruction Set Reference, A-M and Volume 2B: Instruction Set Reference, N-Z). In my January 2006 copy under "MOV—Move", I found:

"Loading the SS register with a MOV instruction inhibits all interrupts until after the execution of the next instruction. This operation allows a stack pointer to be loaded into the ESP register with the next instruction (MOV ESP, stack-pointer value) before an interrupt occurs1." (IA-32 Intel® Architecture Software Developer’s Manual, Volume 2A: Instruction Set Reference, A-M, 253666-018, Jan 2006, "MOV—Move," page 3-584). And footnote 1. clearly states: "If a code instruction breakpoint (for debug) is placed on an instruction located immediately after a MOV SS instruction, the breakpoint may not be triggered." (page 3-585). For those who are new to how a debugger works, the "instruction breakpoint" which this refers to is not a breakpoint set by users, but rather the, let's call it, automatic breakpoint a debugger sets by itself on every single instruction users step into. So, according to these notes, what you may have thought was a "bug" in DEBUG, is in fact a processor doing what it was designed to do!

Does this mean we believe MS-DEBUG is completely "bug free"? No. In the future we'll post some examples here of real 'bugs' in DEBUG.

Before using any of the debugging (Trace, Procedure) or Register commands, you should familiarize yourself with the abbreviations for the CPU Registers that are referenced in DEBUG (See the Appendix, The 8086 CPU Registers for all the details.)

You should also know about the SEGMENT:OFFSET Addressing method used by DEBUG (and other programming utilities).

A note about where and how DEBUG is used in a computer's Memory:

Using DEBUG in a Windows®DOS-box (or CMD prompt) for the first time could easily confuse you! If you open two instances of DEBUG (one per DOS-window) and examine all the memory they can access, you might notice completely different data in many of the same memory locations! The reason is that each application under a Windows™ OS is (theoretically) given its own 4-Gigabyte "Virtual computer" sandbox to play in, and a copy of the critical data within the machine's first Megabyte of Memory is made for each running instance of DEBUG. Only under 16-bit DOS, does DEBUG actually have access to the real Memory locations in which the operating system itself is running; making it much easier to crash the whole system if an error is made. Under Windows®, the theory is that such errors should crash only the open CMD window or application that caused a problem, but not the whole computer! At least that's how Windows® is supposed to operate. From experience, it seems that Windows™ 2000/XP do a much better job at keeping control of their systems under the same circumstances that often ended in Blue Screens on the displays of earlier versions!

Quick Links to all the Commands
(Alphabetically Listed)

We recommend reading through the entire Tutorial on DEBUG before using these quick command links.

For a reminder of all the commands available while inside of DEBUG, simply enter a question mark (?) at the DEBUG prompt; when using DOS 5.0 or later.

Click on a command here for all its details:

-?
assemble    A [address]
compare     C range address
dump        D [range]
enter       E address [list]
fill        F range list
go          G [=address] [addresses]
hex         H value1 value2
input       I port
load        L [address] [drive] [firstsector] [number]
move        M range address
name        N [pathname] [arglist]
output      O port byte
proceed     P [=address] [number]
quit        Q
register    R [register]
search      S range list
trace       T [=address] [number]
unassemble  U [range]
write       W [address] [drive] [firstsector] [number]

Page Two

Updated: December 9, 2007. (09.12.2007)
Updated: February 12, 2009. (12.02.2009)
Updated: August 24, 2009. (24.08.2009)

The Starman's Realm Assembly Page


Notes sur le langage C

Sponsoring website: Emergency Boot CD

FIRE.com : Some MS-DEBUG Tricks
An Exercise in x86 Assembly Language
for
Advanced students and the totally Clueless!
(A free Hex Editor with an ASCII import function)

This page will eventually get around to examining a few ways that DEBUG can be used to study x86 Assembly Language, but first I'd like to present a little illustration which may be a bit confusing at first for some of you...

The following text is a fancy signature which I found appended to the end of a file by someone called The Bitripper. The outline drawing of TB is rather obvious, but you might be asking yourself, "What do the rows of letters and digits mean?" Well, as The Bitripper said (at the end of the last line), you should "c4urself" (See for yourself !) If you already have an idea about why The Bitripper put this (code?) here, then please go ahead and find out on your own before reading any further!

--
  B013CD1033C0BFB001B9007DF3ABBAC803EE42FEC980/~~~~~~~~\      The Bitripper
FB3C730580C304EB0880FF3C730380C7048AC3EE8AC7/'          `\~~~\
EE32C0EEE2E3B1C88106AC01E9628006AC01628116AE`\           /'   )
  011936A1AE0133D2BB4001F7F38BF2FE8C707DE2DDBE`~~/   \~~'    / Coders do it
   F102BFB17EB162BA3E018A9CC0FE8A44FF03D88A4401/`     )      `\  bit by bit
  03D88A84400103D8C1EB02881D46474A75E246464747/       /        )
 E2D9BEB27EBFB201B97E3E5157F3A55E6800A007BF02(_______/        /
          7D59F3A51E07B401CD16748CB80300CD10C3c4urself`.____/'
--

If you don't have the slightest idea where to begin in solving the mystery of these lines, then here are some helpful hints:

Since this signature file was created by an "assembly coder," we'll assume that...

  1. Every two digits of these lines forms a Hexadecimal byte of x86 Machine code (all the letters here are Hex digits too: A thru F; see "What is Hexadecimal?" if you need a detailed introduction to HEXaDecimal).

  2. Although it could turn out differently later on (but I doubt it since coders are so logical), let's drop the phrase 'c4urself ' as having nothing to do with the assembly code (all these letters are in lower case and most of them are NOT Hex digits anyway!)
  3. Viewing the bytes in a Hex editor or with DEBUG (as an ASCII Dump) might give us a clearer picture as to what the lines mean.

So, run off to your Hex editor and find out what it means... ``What's that you say? It's too much typing; there should be a better way to do this!?'' I guess your Hex editor doesn't support importing Hex code from an ASCII based text file!? (If you're interested in one that does; and for free, keep reading.)
First, I'll show you a method that takes a bit longer than importing the code directly, but it will save you from most typos and the chances are it's already installed on your computer: MS-DEBUG (from almost any version of MS-DOS up through WINDOWS 9x/NT or whatever). To check for its presence: Try finding the file debug.exe ; normally found in your C:\WINDOWS\COMMAND folder (9x).

[ For those of you who do NOT have DEBUG available in a DOS-Window, you can download a hex editor with an import function here: Frhed: Free Hex Editor. ( You can also click here: For info on using DOS-Windows.)
IF you DO have access to DEBUG, I encourage you to try learning more about it by working through the data on this page -- even those without DEBUG should skim through this material to see if their own conclusions about the Hex data are correct! At the end of the page I'll describe how FRHED greatly simplifies the process of importing the hex data, if you don't want to use DEBUG.]

OK, Let's Find Out What It Means!

Simply copy and paste the lines into a text editor such as NOTEPAD. First remove the non-Hex characters on the right side and then the blank spaces at the left until all the lines are flush against the left-hand margin. Now you can see that all the lines have the same length EXCEPT for the last one... AFTER you remove the "c4urself" they should look like this:
B013CD1033C0BFB001B9007DF3ABBAC803EE42FEC980
FB3C730580C304EB0880FF3C730380C7048AC3EE8AC7
EE32C0EEE2E3B1C88106AC01E9628006AC01628116AE
011936A1AE0133D2BB4001F7F38BF2FE8C707DE2DDBE
F102BFB17EB162BA3E018A9CC0FE8A44FF03D88A4401
03D88A84400103D8C1EB02881D46474A75E246464747
E2D9BEB27EBFB201B97E3E5157F3A55E6800A007BF02
7D59F3A51E07B401CD16748CB80300CD10C3
Now arrange all the digits so you have only 32 of them (or 16 bytes) per line; this will make it easier to enter the data later on! Your file should now look like this:
B013CD1033C0BFB001B9007DF3ABBAC8
03EE42FEC980FB3C730580C304EB0880
FF3C730380C7048AC3EE8AC7EE32C0EE
E2E3B1C88106AC01E9628006AC016281
16AE011936A1AE0133D2BB4001F7F38B
F2FE8C707DE2DDBEF102BFB17EB162BA
3E018A9CC0FE8A44FF03D88A440103D8
8A84400103D8C1EB02881D46474A75E2
46464747E2D9BEB27EBFB201B97E3E51
57F3A55E6800A007BF027D59F3A51E07
B401CD16748CB80300CD10C3

Unfortunately, DEBUG requires that each byte must be separated by a blank space, so you'll still have to punch a lot of keys ( but this is a lot easier to do AND more accurate than entering each Hex byte manually!):
B0 13 CD 10 33 C0 BF B0 01 B9 00 7D F3 AB BA C8
03 EE 42 FE C9 80 FB 3C 73 05 80 C3 04 EB 08 80
FF 3C 73 03 80 C7 04 8A C3 EE 8A C7 EE 32 C0 EE
E2 E3 B1 C8 81 06 AC 01 E9 62 80 06 AC 01 62 81
16 AE 01 19 36 A1 AE 01 33 D2 BB 40 01 F7 F3 8B
F2 FE 8C 70 7D E2 DD BE F1 02 BF B1 7E B1 62 BA
3E 01 8A 9C C0 FE 8A 44 FF 03 D8 8A 44 01 03 D8
8A 84 40 01 03 D8 C1 EB 02 88 1D 46 47 4A 75 E2
46 46 47 47 E2 D9 BE B2 7E BF B2 01 B9 7E 3E 51
57 F3 A5 5E 68 00 A0 07 BF 02 7D 59 F3 A5 1E 07
B4 01 CD 16 74 8C B8 03 00 CD 10 C3
Were getting close now! A DEBUG Entry command begins with an 'E,' a space and then the first Hexadecimal memory address where the data will be entered followed by the string of bytes to enter. If we can't find some kind of meaningful pattern after viewing an ASCII dump of the bytes, our next step will be to assume they form an executable program. DEBUG can create a .COM program for us if we enter the code beginning at Offset 0100 of the segment in memory it assigns to us. So, we might as well enter the data beginning at offset 100 hex and following... Now you can see that having each line contain exactly 16 bytes makes it easier to count (and less likely for an error to occur):
    E 100 B0 13 CD 10 33 C0 BF B0 01 B9 00 7D F3 AB BA C8
E 110 03 EE 42 FE C9 80 FB 3C 73 05 80 C3 04 EB 08 80
E 120 FF 3C 73 03 80 C7 04 8A C3 EE 8A C7 EE 32 C0 EE
E 130 E2 E3 B1 C8 81 06 AC 01 E9 62 80 06 AC 01 62 81
E 140 16 AE 01 19 36 A1 AE 01 33 D2 BB 40 01 F7 F3 8B
E 150 F2 FE 8C 70 7D E2 DD BE F1 02 BF B1 7E B1 62 BA
E 160 3E 01 8A 9C C0 FE 8A 44 FF 03 D8 8A 44 01 03 D8
E 170 8A 84 40 01 03 D8 C1 EB 02 88 1D 46 47 4A 75 E2
E 180 46 46 47 47 E2 D9 BE B2 7E BF B2 01 B9 7E 3E 51
E 190 57 F3 A5 5E 68 00 A0 07 BF 02 7D 59 F3 A5 1E 07
E 1A0 B4 01 CD 16 74 8C B8 03 00 CD 10 C3
If you entered the data above into DEBUG and then used the DUMP command
- d 100 1ab The only ASCII characters you'd see on the screen would be:
      ....3......}....
..B....<s.......
.<s..........2..
.........b....b.
....6...3..@....
...p}.......~.b.
>......D....D...
..@........FGJu.
FFGG....~....~>Q
W..^h.....}Y....
....t.......
Not very meaningful... So, we assume The Bitripper is showing us a program of some kind. Finally, I've arranged our data in the form of a DEBUG SCRIPT FILE which you can use to quickly and automatically create a program with just a single DOS command! I've used DEBUG's N command to name the program FIRE.COM (you'll find out why later) and added a few more DEBUG commands at the end of the file to change the CX register ( RCX ) to AC (the file is 172 bytes long), the write ( W ) command to save the file to disk and the quit ( Q ) command to exit DEBUG. Make the necessary changes in your text editor and SAVE this file as FIRE.SCP (MAKE CERTAIN that you hit the ENTER key after 'Q' so a new line starts at the end of the file; DEBUG can't quit without this carriage return, and your DOS-window will lock-up if DEBUG can't quit!) :
 N FIRE.COM
 E 0100 B0 13 CD 10 33 C0 BF B0 01 B9 00 7D F3 AB BA C8
 E 0110 03 EE 42 FE C9 80 FB 3C 73 05 80 C3 04 EB 08 80
 E 0120 FF 3C 73 03 80 C7 04 8A C3 EE 8A C7 EE 32 C0 EE
 E 0130 E2 E3 B1 C8 81 06 AC 01 E9 62 80 06 AC 01 62 81
 E 0140 16 AE 01 19 36 A1 AE 01 33 D2 BB 40 01 F7 F3 8B
 E 0150 F2 FE 8C 70 7D E2 DD BE F1 02 BF B1 7E B1 62 BA
 E 0160 3E 01 8A 9C C0 FE 8A 44 FF 03 D8 8A 44 01 03 D8
 E 0170 8A 84 40 01 03 D8 C1 EB 02 88 1D 46 47 4A 75 E2
 E 0180 46 46 47 47 E2 D9 BE B2 7E BF B2 01 B9 7E 3E 51
 E 0190 57 F3 A5 5E 68 00 A0 07 BF 02 7D 59 F3 A5 1E 07
 E 01A0 B4 01 CD 16 74 8C B8 03 00 CD 10 C3
 RCX
 AC
 W
 Q
For those who are interested... "No! I did NOT run this program right away to see what it did; I first examined the Assembly instructions to determine if it was reasonably safe to run on my computer!" I'll show you how to do that soon...
Experimenting with completely unknown programs is best left for a spare computer with a hard drive you're ready to wipe clean as soon as you're through with your experiments! Many kid's computers these days are full of trojans and viruses too!! Those of you with risky friends should NEVER accept floppy disks or download programs from their computers; it's best to just say 'No thanks!' and learn whatever else you can to keep your machine clean (virus free).

Open a DOS-Window and run the following command from whatever folder you stored or moved the SCRIPT file (fire.scp) into... I'm simply using the root directory (C:\) for the command here:
C:\> debug < fire.scp

And here's what you should see on your screen as DEBUG automatically creates the program for you:
C:\> debug < fire.scp
- N FIRE.COM
- E 0100 B0 13 CD 10 33 C0 BF B0 01 B9 00 7D F3 AB BA C8
- E 0110 03 EE 42 FE C9 80 FB 3C 73 05 80 C3 04 EB 08 80
- E 0120 FF 3C 73 03 80 C7 04 8A C3 EE 8A C7 EE 32 C0 EE
- E 0130 E2 E3 B1 C8 81 06 AC 01 E9 62 80 06 AC 01 62 81
- E 0140 16 AE 01 19 36 A1 AE 01 33 D2 BB 40 01 F7 F3 8B
- E 0150 F2 FE 8C 70 7D E2 DD BE F1 02 BF B1 7E B1 62 BA
- E 0160 3E 01 8A 9C C0 FE 8A 44 FF 03 D8 8A 44 01 03 D8
- E 0170 8A 84 40 01 03 D8 C1 EB 02 88 1D 46 47 4A 75 E2
- E 0180 46 46 47 47 E2 D9 BE B2 7E BF B2 01 B9 7E 3E 51
- E 0190 57 F3 A5 5E 68 00 A0 07 BF 02 7D 59 F3 A5 1E 07
- E 01A0 B4 01 CD 16 74 8C B8 03 00 CD 10 C3
- RCX
CX 0000
: AC
- W
Writing 000AC bytes
- Q
You should now find a copy of the program FIRE.COM in the same folder as the SCRIPT file. Before you go off to run the program... especially those of you who want to learn more about using DOS commands... You might like to check out this SCRIPT file for creating an Assembly listing of FIRE.COM using DEBUG again:
 N FIRE.COM
 L               <-- This Loads the named program from the hard drive!
 U 0100 01AB     <-- Un-assemble code from 100h to 1ABh (ACh or 172 bytes).
 Q
Save this file as: FIREASM.SCP (Note: You need to run this SCRIPT in the same folder as the program or it won't know how to find it). Here's the DOS Command that will run the script AND re-direct its output to another file; which I've called FIREASM.TXT :
C:\> debug < fireasm.scp > fireasm.txt

Here's a copy of my output (compare with your own): FIREASM.txt.

So what does FIRE.COM do? It's an animated display of a fire similar to that of a fireplace burning in a DOS-Window on your screen... To exit the program, simply press any key! If you have a slow (100 MHz) processor like I do, you need to run it in Full-Screen mode! I'm not at all sure how it appears for very fast CPUs either in/out of a DOS-Window.

For a corrected Assembly Listing of the program ( including a number of detailed comments), click here: FIRE-ASM.txt. This listing has been updated with some notes from The Bitripper himself! Here's the assembly listing exactly as he sent it to me: BRANCOM9.ASM.

Using FRHED to Import the Hex Code

( NOTE: The standard version of FRHED does NOT do ASCII text importing
into Hex!! So, make sure you obtain the PABS-modified version first. )

First, make sure you have saved the ASCII representation of the Hex code in a text file somewhere. Its contents will be simply:
B013CD1033C0BFB001B9007DF3ABBAC803EE42FEC980
FB3C730580C304EB0880FF3C730380C7048AC3EE8AC7
EE32C0EEE2E3B1C88106AC01E9628006AC01628116AE
011936A1AE0133D2BB4001F7F38BF2FE8C707DE2DDBE
F102BFB17EB162BA3E018A9CC0FE8A44FF03D88A4401
03D88A84400103D8C1EB02881D46474A75E246464747
E2D9BEB27EBFB201B97E3E5157F3A55E6800A007BF02
7D59F3A51E07B401CD16748CB80300CD10C3
Now you can fire-up FRHED... Click on the File menu and choose the item "Import from hexdump..." A Dialog box will pop up allowing you to select the file containing the code. After choosing your file, you'll get a message box asking you to confirm the type of file ( Note: Later versions of Frhed may act differently than what I've shown here! ):

PABS's wording may confuse you here! Since we are NOT using a FRHED-formatted hexdump; just a simple text file containing hex bytes and whitespace (spaces, tabs, or carriage returns are considered such by FRHED here), you must click on the " No " button! If you happen to press the Yes button, you'll most likely see this message box:

Just hit the " Cancel " button and try again... Once the file has been imported into FRHED, it should look similar to this:

At this point you simply save the code as FIRE.COM or whatever else you want to call the program from the File menu.

If you have any questions about this discussion please use my online feedback form here: Comments for the Starman.

[ The Starman. Revised: 16 JUN 2001.]


ASM Mode Reel

Programmation Assembleur Z80

Un livre de Wikilivres.

  • 1 Introduction
  • 2 Les registres
    • 2.1 Stocker des valeurs dans les registres
    • 2.2 Opérations logiques et mathématiques
  • 3 Les flags
    • 3.1 Tableau récapitulatif de l'effet des instructions assembleur Z80 sur les flags

Introduction

L'assembleur, pour le Z80 comme tous les processeurs, est le langage de plus bas niveau de programmation et donc le plus rapide.
Rappelons que ce processeur est fabriqué par Zilog, est cadencé à 8 MHz en utilisation normale et est un processeur 16 bits interne et 8 bits externe. Il a été commercialisé dès 1976, mais on le trouve encore aujourd'hui dans les calculatrices TI-84 et TI-84+. Le Z80 est compatible avec le 8080 de Intel, et on trouve aujourd'hui un processeur compatible, le Z180, avec quelques instructions supplémentaires.

Les registres

Le Z80 contient 22 registres dont certains de 8 bits peuvent être associés par deux pour former un registre de 16 bits. D'autres sont toujours des registres 16 bits (IX):
A, F, B, C, D, E, H, L, IX, IY, SP, PC, I et R ainsi que les registre alternatif A', F', B', C', D', E', H', L'.
Les lettres simples sont des registres 8 bits et les lettres doubles 16 bits.
On peut faire aussi ces associations et seulement celles-ci:
AF, BC, DE, et HL (ainsi que leur registre supplementaire).
Les registres alternatif ne sont pas accessible directement, il faut passer d'une page de registre à l'autre grâce aux instructions EX AF,AF' pour échanger A et F par A' et F', et EXX pour l'échange des registres BC, DE, HL. Ceci permet par exemple les interuptions rapide, cette méthode étant plus rapide qu'une sauvegarde dans la pile.

Le registre A est l'accumulateur, BC et DE sont utilisés comme "tampons" pour les données temporaires, HL est surtout utilisé pour transférer des données dans la mémoire RAM (Random Access Memory).
F est le registre contenant les "Flags" (drapeaux en anglais): il contient entre autres les résultats des opérations.
IX et IY sont les index.
SP (stack pointer) est l'adresse du haut de la pile de donnée et d'appels dans la RAM.
PC (program counter) est l'adresse de l'instruction en cours d'exécution. R est le registre refresh.
I est utilisé pour les interruptions dans certains modes

En règles générales on utilise surtout A,BC,DE,HL en programmation car très peu d'opérations sont possibles sur les autres registres.

Stocker des valeurs dans les registres

Pour stocker des valeurs dans les registres, rien de plus simple:
Il faut utiliser l'instruction LD (contraction de LOAD).
Si on veut stocker , par exemple, la valeur 17 dans la registre A:

  LD A, 17      ;17 est ici noté en décimal

Mais on peut aussi le noter en hexadécimal:

  LD A, $11     ;17 est ici noté en hexadécimal

Cela donne au registre A la valeur 17.
Attention, ce registre est un registre 8 bits qui limite la valeur à 255 en décimal, soit $FF en hexadécimal. Les nombres décimaux et négatifs ne peuvent pas non plus être traités de cette façon.
Nous pouvons faire la même chose avec un autre registre et une autre valeur:

  LD B, 32
  LD C, $18
  LD H, %01001010    ;ici le nombre est noté en binaire: 01001010b = 74d

On peut faire de même avec un registre pair:

  LD BC, 14238   ;ici les valeurs sont en 16 bits
  LD HL, $80DF

Attention les nombres sont ici limités à 65535d.

Une autre façon d'utiliser LD est de charger une donnée d'un registre vers un autre:

  LD B, A

Cela met la valeur du registre A dans le registre B. Comme vous pouvez le voir, dans n'importe quelle utilisation de LD, la donnée est déplacée de la droite vers la gauche. On peut charger un simple registre dans un autre registre.
Attention: on peut charger un registre 8 bits dans un de 16 bits, mais pas l'inverse! Par exemple:

  LD HL,A
/!\ LD A,HL est interdit!

Des utilisations plus compliquées de LD (mais très utiles) impliquent de déplacer des données entre la mémoire (RAM) et les registres. Comme vous le savez, on accède à la mémoire par des adresses. L’instruction LD est utilisée pour charger une donnée entre un registre et une zone mémoire spécifiée par une adresse. Cette adresse peut être une valeur brute:
LD HL, ($80DF)
Ceci charge la valeur enregistrée dans la zone mémoire d’adresse $80DF et la stocke dans le registre HL. Les parenthèses autour du nombre indique que le nombre est utilisé comme une adresse, et non comme une valeur.

Dans l’exemple précédent, nous avons chargé un certain registre à partir d’une adresse spécifique de la mémoire, et avons utilisé le registre HL. Cela signifie que nous ne pouvons pas charger n’importe quel autre registre directement de la mémoire. Pour charger un autre registre, nous chargeons la mémoire dans HL puis l’autre registre avec HL:

  LD HL, ($80DF)
  LD BC, HL n'existe pas, il faut utiliser:
  LD B,H
  LD C,L

Opérations logiques et mathématiques

Il est possible de modifier la valeur d'un registre avec des opérations. La plupart de ces opérations, cependant, affectent seulement le registre A. Les instructions a utiliser sont ADC, ADD, AND, DEC, INC, NEG, OR, RL, RR, SBC, SUB, et XOR. Les instructions AND, OR, et XOR ne peuvent être appliquées qu'au registre A. leur syntaxe est:

AND valeur
OR valeur
XOR valeur

où valeur peut être un registre où une valeur directe (comme 23). Ce sont des opérateurs logiques binaires, AND réalise un ET logique de la valeur donnée avec le registre A dans lequel il va stocker le résultat. OR effectue de la même façon un OU logique inclusif. et XOR un OU exclusif. Par exemple:

LD A,32
OR 16

va donner à A la valeur 48, car si on écrit l'opération en binaire:

00100000 =32
00010000 =16
-------- OU
00110000 =48

Les flags

Les flags sont stockés dans le registre F. Ils sont modifiés par la plupart des instructions et permettent de réaliser principalement des sauts conditionnels.

Si la dernière opération effectuée a donné un résultat nul, alors le flag Z sera actif. Dans le cas contraire, le flag NZ sera actif. S'il y a eu un débordement (le résultat d'une opération est un nombre négatif, ou plus grand que la valeur maxmale que le registre peut contenir), alors le flag C sera actif, et NC est le flag contraire, activé donc s'il n'y a pas eu de débordement.

Tableau récapitulatif de l'effet des instructions assembleur Z80 sur les flags

Instruction | S | Z | PV | C | Instruction | S | Z | PV | C
ADC reg,reg | ? | ? | ? | ? | LDD | . | . | ? | .
ADD A,reg | ? | ? | ? | ? | LDDR | . | . | 0 | .
ADD autre | . | . | . | ? | LDI | . | . | ? | .
AND reg | ? | ? | ? | 0 | LDIR | . | . | 0 | .
BIT reg,reg | ? | ? | ? | . | NEG | . | . | . | .
CALL | . | . | . | . | NOP | . | . | . | .
CCF | . | . | . | ? | OR | ? | ? | ? | 0
CP reg | ? | ? | ? | ? | OTDR | ? | ? | ? | .
CPD | ? | ? | ? | . | OTIR | ? | ? | ? | .
CPDR | ? | ? | ? | . | OUT reg,reg | . | . | . | .
CPI | ? | ? | ? | . | OUTD | ? | ? | ? | .
CPIR | ? | ? | ? | . | OUTI | ? | ? | ? | .
CPL | . | . | . | . | POP reg | . | . | . | .
DAA | ? | ? | ? | . | PUSH reg | . | . | . | .
DEC reg16 | . | . | . | . | RES reg,reg | . | . | . | .
DEC autre | ? | ? | ? | . | RET | . | . | . | .
DI | . | . | . | . | RL | ? | ? | ? | ?
DJNZ | . | . | . | . | RLA | . | . | . | ?
EI | . | . | . | . | RLC reg | ? | ? | ? | ?
EX reg,reg | . | . | . | . | RLCA | . | . | . | ?
EXX | . | . | . | . | RLD | ? | ? | ? | .
HALT | . | . | . | . | RR reg | ? | ? | ? | ?
IM reg | . | . | . | . | RRA | . | . | . | ?
IN reg,reg | ? | ? | ? | . | RRC reg | ? | ? | ? | ?
INC reg16 | . | . | . | . | RRCA | . | . | . | ?
INC autre | ? | ? | ? | . | RRD | ? | ? | ? | .
IND | ? | ? | ? | . | RST reg | . | . | . | .
INDR | ? | ? | ? | . | SBC reg,reg | ? | ? | ? | ?
INI | ? | ? | ? | . | SCF | . | . | . | 1
INIR | ? | ? | ? | . | SET reg,reg | . | . | . | .
JP reg | . | . | . | . | SLA | ? | ? | ? | ?
JR reg | . | . | . | . | SRA | ? | ? | ? | ?
LD A,I | ? | ? | ? | . | SRL | ? | ? | ? | ?
LD A,R | ? | ? | ? | . | SUB | ? | ? | ? | ?
LD autre | . | . | . | . | XOR | ? | ? | ? | 0

? indique que le flag peut être modifié dans certains cas,
. indique que le flag n'est jamais modifié,
0 ou 1 indique que le flag prend toujours cette valeur.

Récupérée de « http://fr.wikibooks.org/w/index.php?title=Programmation_Assembleur_Z80&oldid=190394 »


The Segment:Offset Addressing Scheme

Sponsoring website: Emergency Boot CD

Removing the Mystery from
SEGMENT : OFFSET
Addressing

Copyright©2001, 2007 by Daniel B. Sedory

This page may be freely copied for PERSONAL use ONLY !
( It may NOT be used for ANY other purpose unless you have
first contacted and received permission from the author! )

For information on using MS-DEBUG, see A Guide to DEBUG.

  • Section 1. Introduction, Definitions and Statistics

  • Section 2. Vizualizing the Overlapping Segments
    • The Upper Memory Area (UMA)
    • The High Memory Area (HMA)

  • Section 3. Normalized Segment:Offset Notation

  • Section 4. Problems when Segment Register Values are not considered !
    •
Introduction.

There are often many different Segment:Offset pairs which can be used to address the same location in your computer's memory. This scheme is a relative way of viewing computer memory as opposed to a Linear or Absolute addressing scheme. When an Absolute addressing scheme is used, each memory location has its own unique designation; which is a much easier way for people to view things. So, why did anyone ever create this awkward "Segment:Offset scheme" for dealing with computer memory? As an answer, here's a brief lesson on the 8086 CPU with an historical slant:

 Segment:Offset addressing was introduced at a time when the largest register in a CPU was only 16-bits long which meant it could address only 65,536 bytes (64 KiB[1]) of memory, directly. But everyone was hungry for a way to run much larger programs! Rather than create a CPU with larger register sizes (as some CPU manufacturers had done), the designers at Intel decided to keep the 16-bit registers for their new 8086 CPU and added a different way to access more memory: They expanded the instruction set, so programs could tell the CPU to group two 16-bit registers together whenever they needed to refer to an Absolute memory location beyond 64 KiB.

If the designers had allowed the CPU to combine two registers into a high and low pair of 32-bits, it could have referenced up to 4 GiB[2] of memory in a linear fashion! Keep in mind, however, this was at a time when many never dreamed we'd need a PC with more than 640 KiB of memory for user applications and data![3] So, instead of dealing with whatever problems a linear addressing scheme of 32-bits would have produced, they created the Segment:Offset scheme which allows a CPU to effectively address about 1 MiB of memory.[4]

The scheme works like this: The value in any register considered to be a Segment register is multiplied by 16 (or shifted one hexadecimal byte to the left; add an extra 0 to the end of the hex number) and then the value in an Offset register is added to it. So, the Absolute address for any combination of Segment and Offset pairs is found by using the formula:

Absolute
Memory
Location

= (Segment value * 16) + Offset value

After working through some examples, this will become much clearer to understand: The Absolute or Linear address for the Segment:Offset pair, F000:FFFD can be computed quite easily in your mind by simply inserting a zero at the end of the Segment value ( which is the same as multiplying by 16 ) and then adding the Offset value:
                F0000
           + FFFD
           ------
            FFFFD  or  1,048,573(decimal)

Here's another example: 923F:E2FF ->

            923F0
           + E2FF
           ------
            A06EF   or   657,135(decimal)
Now let's compute the Absolute Memory location for the largest value that can be expressed using a Segment:Offset reference:
                FFFF0
          +  FFFF
          -------
           10FFEF  or  1,114,095 (decimal)
In reality, it wasn't until quite some time after the 8086, that such a large value actually corresponded to a real Memory location. Once it became common for PCs to have over 1MiB of memory, programmers developed ways to use it to their advantage and this last byte became part of what's now called the HMA (High Memory Area). But until that time, if a program tried to use a Segment:Offset pair that exceeded a 20-bit Absolute address (1MiB), the CPU would truncate the highest bit (an 8086/8088 CPU has only 20 address lines), effectively mapping any value over FFFFFh (1,048,575) to an address within the first Segment. Thus, 10FFEFh was mapped to FFEFh.[5]

One of the downsides in using Segment:Offset pairs (and likely what confuses most of you) is the fact that a large number of these pairs refer to the same exact memory locations. For example, every Segment:Offset pair below, refers to exactly the same location in memory:

  0007:7B90   0008:7B80   0009:7B70   000A:7B60   000B:7B50   000C:7B40

  0047:7790   0048:7780   0049:7770   004A:7760   004B:7750   004C:7740

  0077:7490   0078:7480   0079:7470   007A:7460   007B:7450   007C:7440

  01FF:5C10   0200:5C00   0201:5BF0   0202:5BE0   0203:5BD0   0204:5BC0

  07BB:0050   07BC:0040   07BD:0030   07BE:0020   07BF:0010   07C0:0000
The Segment:Offset pairs listed above are only some of the many
ways one can refer to the single Absolute Memory location of:
7C00 h (or 0000:7C00).

As a matter of fact there may be up to4,096 different Segment:Offset pairs for addressing a single byte in Memory; depending upon its particular location. For Absolute addresses 0h through FFEFh ( 0 through 65,519 ), the number of different pairs can be computed as follows: Divide the Absolute address by 16 ( which shifts all the hex digits one place to the right ), then throw away any fractional remainder and add 1. This is the same thing as saying: Add 1 to the Segment number if the Offset is 000Fh (15) or less. For example, the byte in memory referenced by the Segment:Offset pair 0040:0000 has a total of 41h (or 65) different pairs that might be used. For the Absolute address 7C00h, which was mentioned above, there's a total of: 7C00 / 10h --> 7C0 + 1 = 7C1 (or 1,985) relative ways to address this same memory location using Segment:Offset pairs. For the Absolute addresses from FFF0h (65,520) all the way through FFFFFh (1,048,575), there will always be 4,096 Segment:Offset pairs one could use to refer to these addresses! That's a little over 88% of the memory that can be accessed using Segment:Offsets. The last 65,520 bytes that can be accessed by this method are collectively called the High Memory Area (HMA). For each 16 bytes higher in the HMA that we point to, there is one less Segment:Offset pair available to reference that paragraph.

Due to the sheer number of possible Segment:Offset pairs for each address, most programmers have agreed to use the same normalization method (see the note below on Normalized Notation) when writing about a particular location in Memory.

We've created some graphic illustrations to help you picture the boundaries between various areas of Memory:

Visualizing the Overlapping Segments

The following illustrations should help students visualize the artificial layout of the Segment boundaries in a system's Memory.

SEGMENTS are more like a mental construct or a way of visualizing a computer's Memory, rather than being closely tied to the physical hardware itself. In Figure 0, we've tried to show how each Segment of 65,536 bytes overlaps most of the preceding Segment. As you can see, each Segment begins only 16 bytes (or a paragraph) after the preceding one. In computer terminology, a paragraph is used to refer to 16 consecutive bytes of Memory. For every 16 bytes higher in Memory that we point to, the number of overlapping Segments will increase by one until we arrive at the end of the first Segment. At that point, each successive paragraph of Memory (up to 1MiB) has a constant number of 4,096 overlapping Segments! Figure 0 also shows the Segment:Offset values for each of the four corners of the first five of Segments.

In Figure 1 (see below), the focus is on just the beginning of Segments 1, 2, 3 and so on, rather than the whole Segment. Notice how the first 16 bytes of memory appear in the Figure. There's only one segment there: no other segments overlap these bytes. Therefore, the Segment:Offset pairs for each of the first 16 bytes in memory is actually unique! There's only one way to refer to them: with the Segment value of 0000: and one of the 16 Offsets, 0000 through 000F hex. The next 16 bytes in memory (10h through 1Fh) will each have precisely two different Segment:Offset pairs that can be used to address them. For each of the first five Segments, the exact number of equivalent Segment:Offset pairs for the last byte in the paragraph has been shown in the aqua (light-blue) colored boxes.

(For comments on the part of Figure 1 under the BLUE line, see text below.)

The second part of Figure 1 above, shows what happens at the transition from a paragraph of memory that is still within the boundary of the first 64kb Segment (Absolute addresses FFF0h through FFFFh) to those paragraphs which are beyond its boundary (10000h and following). Note that the first paragraph of Segment 0FFF: (which is the same as the last 16 bytes within Segment 0000:) is the first paragraph in Memory to have a total of 4,096 different Segment:Offset pairs that could be used to reference its bytes.

Figure 2 shows that Segment 9000: is the last whole 64kb segment to lie within the bounds of what's called " Conventional Memory " ( the first 640kb or 655,360 bytes). The first paragraph of Segment A000: is the beginning of the Upper Memory Area (UMA). The UMA contains a total of 384kb or 393,216 bytes. Segment F000: is the last whole segment that lies within the bounds of the UMA.

640 KiB + 384 KiB = 1024 KiB (or 1,048,576 bytes) = 1 Mebibyte.
(A long time ago, the UMA was called the 'Reserved Area.')

Another way of looking at the first 1MiB of Memory (and hopefully something that will help those who might still be a bit confused ) is the fact that each of these 1,048,576 bytes can be accessed by using one of just the following 16 Segment references ( none of which overlap any of the others): 0000:, 1000:, 2000:, ... 9000: and A000: through F000: plus one of their 65,536 Offsets. Although it would really be nice if we could always refer to a particular byte in Memory using just these 16 Segments, that would be rather wasteful of memory resources: When it comes time for an OS like Windows to assign a full 64kb of free memory to an App such as DEBUG, it's not simply a matter of convenience for it to use the very first 16-byte Segment reference of continuous memory that it can find. Moving up to the next even 1000h Segment would leave even more unused holes in Memory than there are already! (There is, however, an agreed upon convention called Normalized Addressing which has been very helpful.)

Figure 3 shows the end of the UMA and the beginning of the last Segment (Segment FFFF:) in the Segment:Offset scheme. When the 8086 was first created, there wasn't even 640kb of memory in most PCs. And as you might recall from our history lesson above, addresses in this part of the Segment:Offset scheme were first mapped to bytes in Segment 0000. Later, the memory above 1MiB that could still be accessed using Segment:Offset pairs became known as The High Memory Area (HMA).

The High Memory Area (HMA) contains only one paragraph short of 64kb (or just 65,520 bytes). Segment FFFF: is the only segment that can reach the last 16 bytes of the HMA. Here's a text file of a boring Table of HMA Segment:Offset pairs which shows how the number of pairs decreases to only one for the last 16 bytes of the HMA.

Normalized Segment:Offset Notation

Since there are so many different ways that a single byte in Memory might be referenced using Segment:Offset pairs, most programmers have agreed to use the same convention to normalize all such pairs into values that will always be unique. These unique pairs are called a Normalized Address or Pointer.

By confining the Offset to just the Hex values 0h through Fh (16 hex digits); or a single paragraph and setting the Segment value accordingly, we have a unique way to reference all Segment:Offset Memory pair locations. To convert an arbitrary Segment:Offset pair into a normalized address or pointer is a two-step process that's quite easy for an assembly programmer:

  1. Convert the pairs into a single physical (linear) address.
  2. Then simply insert the colon (:) between the last two hex digits!

For example, in order to normalize 1000:1B0F, the steps are:

1000:1B0F [image] 11B0Fh [image] 11B0:F (or 11B0:000F)

Since the normalized form will always have three leading zero bytes in its Offset, programmers often write it with just the digit that counts as shown here: 11B0:F (when you see an address like this, it's almost a sure sign that the author is using this normalized notation).

How Segment:Offset notation can lead to Problems

The normalized notation for the first byte where all PC BIOS must place a floppy diskette's boot strap code is: 07C0:0 (or 07C0:0000). A big problem for some PC manufacturers came about when some BIOS writer assumed that there'd be nothing wrong with jumping to the bootstrap code at that particular Segment:Offset pair, since it's the same memory location as 0000:7C00.
Somehow they never took into consideration the fact that the standard used by everyone else always set the SEGMENT values to ZERO. Therefore, a bootstrap code programmer could assume all Segment values (Code, Data, etc.) were zero and only have to deal with the Offset values in that Segment. Along comes this BIOS chip clone that sets the Code Segment to 07C0 (using a JMP 07C0:000 instruction), and suddenly there was a big problem getting most OS bootstrap code (including Microsoft® and IBM® OSs) to boot up in these computers! This is why some bootstrap code, such as that in the GRUB Boot Manager, will add extra instructions to make sure the Segment Registers have been set correctly! One of the authors of GRUB comments that his Long Jump code was necessary "because some bogus BIOSes jump to 07C0:0000 instead of 0000:7C00."

Footnotes

1[Return to Text] KiB is the abbreviation for a kibibyte (a contraction of kilo binary byte) or binary kilobyte. It is equal to 2 to the 10th power (2^10) or 1024 bytes. Likewise, MiB is a mebibyte (mega binary byte); equal to 2 to the 20th power (2^20) or 1,048,576 bytes, and GiB is a gibibyte (giga binary byte); equal to 2 to the 30th power (2^30) or 1,073,741,824 bytes. In this document, which refers to memory in early IBM PCs (and the Intel 8086 and 80286 CPUs), we may at times refer to kibibytes using the abbreviation "kb" instead of KiB. (It is taking a long time for "kibi-", "mebi-" and "gibi-" to be recognized by techs and computer sales departments as the proper way to refer to memory ; even though they have been in official standards organizations for many years. See, for example, [image] NIST: Prefixes for binary multiples, and [image] Adoption by IEC and NIST.)

64 KiB is also equal to 2 to the 16th power [ (2^16) = (2^10) x (2^6) = (1024) x (64) = 65,536 ] bytes, and each of the two-byte (or 16-bit) registers in an 8086 CPU can contain a maximum value of: 1111 1111 1111 1111 in binary or FFFFh (hexadecimal). In decimal, that's: [(15 x 16^3) + (15 x 16^2) + (15 x 16^1) + 15] = [(15 x 4096) + (15 x 256) + (15 x 16) + 15] = 61,440 + 3,840 + 240 + 15 = 65,535. However, since memory always begins with zero (0) as its first location, that gives us 65,535 + 1 = 65,536 (or, 16^4) memory locations. 65,536 divided by 1024 per KiB = 64 KiB of memory. For more on the use of Hexadecimal in computers, see: What Is "Hexadecimal"?

2[Return to Text] This is 4 gibibytes (see Footnote #1) or 4 times (2^30) = 4,294,967,296 bytes.

3[Return to Text] We've often heard that Bill Gates said something to the effect: ‘640K of memory should be enough for anyone.’ Though many of us no longer believe he ever said those exact words (and he has finally made some public denials concerning this), he did, however, during a video interview with David Allison in 1993 for the National Museum of American History, Smithsonian Institution, say: "I laid out memory so the bottom 640K was general purpose RAM and the upper 384 I reserved for video and ROM, and things like that. That is why they talk about the 640K limit. It is actually a limit, not of the software, in any way, shape, or form, it is the limit of the microprocessor. That thing generates addresses, 20-bits addresses, that only can address a megabyte of memory. And, therefore, all the applications are tied to that limit. It was ten times what we had before. But to my surprise, we ran out of that address base for applications within -- oh five or six years people were complaining." (from [image] a transcript of the interview, under the "Microsoft and the Mouse" section). For a bit more info, see: Did Bill Gates say the 640k line? and perhaps of more interest to others, here are some [image] verifiable quotes from Mr. Gates.

4[Return to Text] 1 MiB of memory is 1,048,576 bytes (2^20 bytes), but the Segment:Offset addressing scheme actually allows one to access up to 10FFEFh, plus one, bytes of memory, or 1,114,096 bytes. We'll have more to say about this and the HMA (High Memory Area) shortly.

5[Return to Text] As we said above, until an IBM PC (or clone) actually had more than 1MiB of memory, it was expedient for the early IBM PCs to effectively wrap-around to the beginning of memory whenever programs tried to access an address past FFFFFh bytes.
[Sorry, this FOOTNOTE IS STILL UNDER CONSTRUCTION! It will soon have some links about the IBM PC AT model's keyboard and the infamous A20 line!]

Last Revised: 15 OCT 2007 (15.10.2007).

You can write to me using this: online reply form. (It opens in a new window.)

The Starman's ASSEMBLY Index Page

The Starman's Realm Index Page


MASM Source Code Compiling

Sponsoring website: Emergency Boot CD
How to use the Microsoft® Assembler
MASM (ml.exe) and LINK.EXE
to compile your Assembly
Language Source Code

Copyright © 2004 by Daniel B. Sedory
NOT to be reproduced in any form without Permission of the Author!

The following links are due to the work of [image] Jon Kirwan who has done an excellent job in keeping us informed about MASM and related software! I've tried to simplify here how most Windows® users can obtain and install MASM on their system. If you need a purely MS-DOS (16-bit) version of MASM, then take the link above to Jon Kirwan's page!

On Microsoft®'s Visual C++ 6.0 Processor Pack [image] Download page, there are links to an SP4 or SP5 update which are publically available for download. Both the SP4 and SP5 files contain the same version (6.15) of MASM (ML.EXE) and its associated Error file (ML.ERR). V.6.15 will only work in a DOS (Command-line) box under Windows®, but this is good news for many Windows® users; especially if you are using Windows™ 2000/XP/2003, but still want to learn how to compile a PC (x86) Assembly program.

Steps to Extract/Install MASM Files

1) Download either SP4 (vcpp.exe; 1160 KiB) or SP5 (vcpp5.exe; 1154 KiB).
You do not need both! Each link has exactly the same files we need to run MASM.

2) If you can extract files from within a Microsoft .CAB file (see #4 below), then change the file extension from .exe to .CAB and proceed to #3. (First, read the "NOTE:"* below.)
Or:
If you'd rather extract every single file from SP4 or SP5 (without using a .CAB extraction program) and read the EULA, then skip #3 below and enter the following command in a DOS box at the directory where you've stored the SP4 or SP5 file, C:\TEMP for example:
C:\TEMP>vcpp5 /c /t:C:\MASM615
(the "/c" command means it will "Extract files only" when also used with the "/t:<full path>" command which specifies the location).
Before proceeding to step #5, read through step #4 so you know which files are actually necessary to run MASM; most of them will have nothing to do with it!

*NOTE: The EULA implies that you should have a licensed version of either "Visual Studio" or "Visual C++" (something you would definitely need to have if you wanted to legally sell a "commercial" program using MASM!). However, the letters that Jon Kirwan exchanged with a Microsoft employee (see link above) seem to imply that Microsoft wants to encourage academic (personal?) use of MASM so long as you do not go to them with 'support questions' without a valid license. If you feel a need to pursue this any further, you'll have to go to Microsoft (and/or others) for answers.

3) Create a directory for MASM, such as C:\MASM615.

4) Use your favorite .CAB tool, such as [image] WinZip (demo available) which can extract files from .CAB archives, to extract only the following files to the directory you just created:
ml.exe 385,072 bytes 03/16/2000 04:20p
ml.err 9,687 bytes 03/16/2000 04:20p
[ Although Windows™ XP/2003 can work with .zip archives, it appears you cannot extract individual files from .CAB archives using only the OS. Does anyone know of a free .CAB extraction tool? ]
MasmRef.doc (513,536 bytes; 08/09/2000, 2:28 PM), will also be helpful to you; feel free to look through "procpack.chm" as well, though its mostly for professional programmers.
Although they're not really necessary, you might as well grab these next two files:
h2inc.exe 249,344 bytes 09/19/1995 02:04p
h2inc.err 21,880 bytes 09/19/1995 02:04p
'h2inc' allows you to convert C language include files into assembly include files; we've never used it, but you might find a need for it some day.

5) Download the file, LNK563.EXE, from either here: HTTP site or here: FTP site into your MASM directory.

6) You can either open this self-extracting file (LNK563.EXE) with a .ZIP tool such as WinZip, or execute it; if you do the latter, delete the README.TXT file which can be very confusing as it refers to this file as a "patch," but these are the full versions of:
LINK.EXE 364,544 bytes 01/13/1995 02:10p and
CVPACK.EXE 169,472 bytes 01/13/1995 02:10p (A CodeView debug information compactor which most of you won't ever have a reason to use, but here it is.)

And that's all there is to it! You're now ready to compile programs from any .asm source code written for MASM. Open a DOS-box (see "Helpful HINT" below) at your MASM directory, and ENTERml /? > ML.TXT at the prompt. ML.TXT will then contain a simple listing of all the switches you can use with MASM. ENTERml all by itself, and you should see:

Microsoft (R) Macro Assembler Version 6.15.8803
Copyright (C) Microsoft Corp 1981-2000. All rights reserved.
usage: ML [ options ] filelist [ /link linkoptions]

Helpful HINT: Install the Win2000/XP "Power Toy" that allows you to open a Command-Line (.CMD) window at any folder by simply right-clicking on the folder name in Windows Explorer and selecting "Command Prompt Here" from the menu. You'll probably find a lot more use for .CMD and Batch files after doing this! Direct Link:
http://download.microsoft.com/download/whistler/Install/2/WXP/EN-US/CmdHerePowertoySetup.exe (513 KiB). [Note: The Power Calculator is the only other program I'd recommend from this series. I would not use the TweakUI program!]

At this point, I'd recommend going through a very nice tutorial by Jon Kirwan called: Learn ASM. It not only covers the basics of using MASM along with some example source code, but includes valuable information on subjects such as the PSP (Program Segment Prefix), the difference between a .COM and .EXE program file, the EXE Header fields at the beginning of all .EXE files plus historical background you'd rarely find in most tutorials.

Once you've done that, go ahead and download the following .asm source code which will teach you a bit more about Assembly code under MASM: DOSWIN.ASM. (Download to your MASM directory and follow the instructions inside the file.) After compiling and running the program, you should open it under DEBUG and step through each instruction until you have understood what each of them do!

In one of the paragraphs above, I mentioned that you can now compile .asm source code "written for MASM." This refers to the fact that souce code written for other assemblers, such as Borland®'s Turbo Assembler (TASM) which we also consider to be quite good, may use Macro statements which MASM has no idea how to understand, and vice versa. Note that the command-line switches used by a particular assembler often have a completely different function under that of another! A seasoned x86 programmer will most likely have learned how to translate the source code for one to the other (or be able to slog through it) out of necessity, needing to implement some code snippets found only for one in a project using another assembler. Sooner or later, you'll need to consult the manuals which describe all the special directives you can use under each assembler. For now though, you should concentrate on learning the basic Assembly mnemonics used by all of them.

Last Update: 26 JAN 2005. (26.01.2005)

You can write to me using this: online reply form. (It opens in a new window.)

MBR and Boot Records Index


ASM and C Projects: Displaying ASCII Characters

Sponsoring website: Emergency Boot CD

Projects: Disassembling and Debugging
Assembly and C Programs that
Display ASCII Characters Onscreen
( Exercises in x86 Assembly Language and MS-DEBUG)

I'll explain how to use DEBUG to disassemble and step through a few 8086 Assembly programs here, and also comment on how complex the code from "C compilers" can become versus that of small .COM programs in which the programmers often write their own Machine code in Assembly Language.

If you have no experience whatsoever with DEBUG, I suggest that you first work through my Guide to DEBUG (make sure to work on the DEBUG program listed under the ENTER [e] command as it concerns displaying all the Extended ASCII characters on screen), and then study the Detailed Step-by-step Analysis of the EICAR Program to gain experience in using more DEBUG commands before finally coming back to this page.

Since our first Assembly program is only 69 bytes long, you can simply "Copy and Paste" the following Enter Data commands into DEBUG:

e 100 b8 00 02 ba 00 00 b9 16 00 50 52 51 e8 13 00 59
e 110 5a 58 cd 21 42 50 52 51 e8 15 00 59 5a 58 e2 e9
e 120 eb 1e b8 00 02 ba 2e 00 b9 03 00 cd 21 e2 fc c3
e 130 e8 ef ff ba 3b 01 b4 09 cd 21 c3 0d 0a 24 90 90
e 140 b8 00 4c cd 21
Then type these commands at the DEBUG prompts to create the program file called disp22.com ( it will be created in the same folder DEBUG was started from):
-n disp22.com
-rcx
CX 0000
:45             [ 69 bytes in decimal ]
-w
-q
This program simply displays the bytes 00h through 15h (a total of 22 characters) each on a separate line with three dots on either side of the character itself.
Note: Some of these bytes will move the cursor position or perform some other action instead of displaying a character on your screen.

PROJECT: Once you've run the program to see what the output looks like, use DEBUG's U (unassemble) command to disassemble it into its Assembly Language code for reference. You can make a 1 pass disassembly listing quite easily by creating and saving a text file with the following lines (and then following my instructions below):

n disp22.com
l
u 100 13a
d 13b 13d
u 13e 144
q

( Make sure you press the ENTER key once or even twice after typing this 'q' -- if not, DEBUG will 'lock up' waiting for a RETURN you'll never be able to enter.
NOTE: I saved you the trouble of having to figure out later that the bytes from 13b to 13d are DATA; not instructions. Commercial disassemblers often make many passes through code trying to determine the difference between Code and Data elements. )

You can name this file anything you want, but I'll use the name, disp22.dsf, here. Run this Debug script file in the same folder as disp22.com from a command line prompt like this:

  C:\temp>debug < disp22.dsf > disp22.asm

which redirects the normal DEBUG screen output into the file disp22.asm. ( Unfortunately, and I have no idea why it should be so, but the file this creates has many spaces at the end of each line, and sometimes you need to add more RETURNS after saving it in Notepad.) Clean up the file as best you can, then try separating the Subroutines (sections of code that are pointed to by CALL instructions) from the rest of the code and data.

Open the program disp22.com in DEBUG, and try stepping through it using the T (Trace) and P (Proceed) commands (while making reference to your Assembly lising) until you understand how it operates. [ CAUTION: Always use the Proceed command to execute any 'INT' instruction, or you'll find yourself trying to trace through a huge section of the computer's BIOS code instead of just this little program! ] You should be able to place some comments in your Assembly listing describing how various instructions affect the program and/or its output, or labeling the names of the BIOS or DOS INTerrupt(s) that are used to display data on the screen. You can send me questions or comments about the code using this online Form.

FOR EXTRA CREDIT:

What you see here is the output from another simple Assembly program similar to the one discussed above. But this program first displays the Hexadecimal value of each byte that the program attempts to display a character for on the screen. Can you write an Assembly program that produces the same output?

If you're interested in doing this, but have problems along the way, I'll try to help you without giving away too much of how to do it.

DISP32.COM running under a .PIF file set to display in a DOS-Window of 43 lines per page using a 7 x 12 Bitmap Font.

HINT: There are many different ways to write programs that can all produce the same output. I just happened to use LOOP and INC instructions to create the Hexadecimal numbers similar to disp22.com's routines.

Looking Inside a Simple C Program

The following program was created with a " C Language " Source Compiler and Linker. I want you to see how much extra code is added to what is a relatively simple source code... All kinds of routines for checking what version of DOS you are running to various Memory Allocation calls, etc. add thousands of bytes that seem to have nothing to do with what I wrote in my Source code file:
    CHARTYPE.EXE - A very simple C Language Character "Typecasting" program [ 10 kb .zip file ]
    ( Includes Commented Source Code for beginners!) -- All of the 256 Extended ASCII characters that can be displayed using C's 'printf ' and 'char' functions are shown on three separate screen pages. Compiled to run with only an 8086 CPU.     Assuming you're running a Windows OS, the program looks best when the display Properties for the DOS-Window are set to run 'Full-Screen' ( Help on setting DOS-Window controls).

After running Chartype.exe once or twice on your computer, open the program in NOTEPAD and under the 'Edit' menu, select 'WordWrap' before proceeding... then press the 'CTRL + END' keys to go to the end of the file where you'll see a lot of the program's text. Note that there's an extra line of text near the bottom that has nothing to do with what you saw in the program's output: "COMPAQ print scanf : floating point formats not linked" and moving up to the beginning of this text section, you'll also find a phrase that's purely for identifying the type of compiler/linker I used, "Borland C++ - Copyright 1991 Borland Intl."

IF you are running Windows 9x/ME (the NOTEPAD in 2000/XP doesn't have this problem): When exiting NOTEPAD, MAKE SURE YOU click on the 'NO' button in answer to the question: Do you want to save the changes? For some weird reason, if you save it this way (even though you simply Word-wrapped the file), Notepad will convert every single 00-byte of a binary file to a space character (20h); making the executable completely useless! I suggest that all Windows 9x/ME users obtain TheGUN.exe from my FreeTools page (to replace NOTEPAD); you'll be able to open files of any size with it, and never have to worry about this word-wrap nusance!

Although it's possible to open Chartype.exe in MS-DEBUG and begin stepping through the code with the Proceed or Trace commands, you'll most likely become bored very quickly since Borland's compiler added lots of extra 'housekeeping' routines concerning DOS handles and Memory allocation right at the beginning of the code... If you really want to work through the relevant parts of this program, here's a time-saving tip: You can immediately skip to the instruction beginning at CS:0291 with the command: g 291 to bypass all that Borland stuff. But even then, there are lots of lines of code that seem quite wasteful compared to an Assembly program... Some important subroutines are found at 055D and 1A94 both of which call many other subroutines which will put your head into a spin unless you take the time to disassemble the whole program before trying to find the the very few lines of code that actually call a BIOS Video INTerrupt to display the characters on your screen! (Note: Locations 0CB9 thru 0CE8 and 0F45 thru 0F68 are all DATA locations not CODE even though they are found in the Code Section of the program! Anything found in the Data Section should always be DATA though.) There are at least five different video functions used in this program (due to some 'convoluted' programming there are actually others), and they're all found in one subroutine that's 161 bytes long. Can you tell me where it's located and/or what the five explicit video functions are called?

If you have any questions about these programs or discussions, please use my online feedback form here: Comments/Questions for The Starman.

 [ The Starman. Revised: 27 OCT 2001.]
Last Update: 27 JUN 2003.


An Examination of the EICAR's Standard A-V Test Program

Sponsoring website: Emergency Boot CD

A Tutorial in x86 Assembly Language:
An Examination
of the
EICAR Standard AV Test Program
Including
A step-by-step Analysis of its Operation
using
Microsoft's DEBUG Program

The EICAR (European Institute for Computer Anti-Virus Research ) Standard AV Test Program has two slightly different forms (designated as eicar68.com and eicar70.com. The digits signify how many bytes are in each file). The larger file is often created when a text editor places the cursor on a newline before saving it (MS-DOS's EDIT.COM in text mode does this); which adds the hexadecimal bytes 0D and 0A (a carriage return and linefeed ) to the end of the file. This does not affect the program's operation in any way; it functions the same no matter how many extra bytes are place at the end of its file (unless your OS refuses to execute a .COM file that exceeds the old 64 KiB memory limit). From this point on we'll refer to any of its formats (68, 70 or whatever length) as simply EICAR.COM.

    There appears to have been three main requirements for this program

    1. That it be a normal DOS program capable of producing the same results under WINDOWS as well as real DOS mode.

    2. That it would identify itself upon execution; displaying a brief explanation of its purpose.

    3. That it contain only characters which could be displayed equally well in both DOS and Windows; i.e., the standard ASCII display characters.

    4. That all of its bytes be limited only to values for upper-case letters, digits and common punctuation marks; excluding spaces (20h), which are not allowed.

The reason for this last requirement was to make it possible for the program to be created using only a text editor; the exclusion of spaces leaves no doubt about the total number of bytes. Another benefit of limiting the program to ASCII characters only is the ease of transmission by any email client/server.

Requirements 3 and 4, meant that the programmer could only use the HEX bytes 21 - 60 and 7B - 7E. But the only way a DOS program can send characters to the display screen is through an "interrupt function," and all x86 interrupts must begin with the hex byte, CD (decimal = 205). This obviously exceeds the range of the standard ASCII characters ( 0 to 127). So how did they do it? That's one of the things you'll learn by going through this tutorial.

Most programmers today rarely if ever deal with the kind of details presented in this tutorial. We wrote this page so students and even the average PC user could appreciate both the complexity involved in running a very simple program and early programmers of the past. Programmers today normally use high-level macro instructions and libraries of pre-assembled code. A single statement in these high-level languages often produces the equivalent of dozens to even pages full of assembly instructions compared to the few we'll be examining here.

Obtaining or Creating Eicar.com

In the past, we tried creating a simple alternative EicarM.com self-modifying file, so students could study how these programs operate without setting off an 'AV alarm' (or having to deactivate their AV program), but AV programs soon became far less selective (checking only a small number of bytes it decides are indicative of an infection) so we shelved that idea!

NOTE: If you're using an Anti-Virus program, set to run in the background, be aware that eicar.com should "set-off" an alarm when you access the file. That's what it's supposed to do. Once you're sure that it is *not* a real virus (your AV program should tell you that it's the eicar test program), then you can either set it to exclude eicar.com or disable your AV program for the remainder of this session. If your AV program doesn't alert you immediately (when you either create or extract eicar.com from the .zip archive), then it's most likely set to do manual scanning only; scan the file (as you would any other program you download) to see if your AV alerts you!

Unfortunately, if your only computer is on a LAN at a school, triggering the AV-alarm might cause you a problem! If it doesn't, and/or your AV program is disabled or only does manual scans, then executing EICAR.COM should print out the following when run in a DOS-box:
EICAR-STANDARD-ANTIVIRUS-TEST-FILE!
Even if you can't run the program at all (say you're using a workstation in a Library for example), you could still learn something by viewing the pics and reading the information presented here.

Download the file now (with a brief text description of the program) from The Starman's Realm: Eicar.zip . Or, create it yourself by pasting the following characters into Notepad and saving the file with a .com extension (or change it later; some text editors will always change a file's extension to .txt, so you might get a filename like 'eicar.com.txt' and need to change it anyway).

The eicar.com program:

X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
( If you need them, you'll find complete instructions here on my What is a Virus? page. )

Warning: Using the W (write) command in DEBUG can result in loss of data on your hard drive! Do NOT experiment with this command. For more information, see Guide to DEBUG.

Loading eicar.com into Debug

Place the file eicar.com into some folder (for example, I'm using C:\TEMP) and note its location. If you've never used a DOS-window before, you should read my page How to Use a DOS Window; others may wish to skim its contents for new information. I've also compiled a list of the DOS 7 Internal Commands here, but the only two you might need to use are the cd (Change Directory) command ( to get to the folder where you stored eicar.com) and the exit command ( to end your DOS session). DOS-windows usually open at the C:\WINDOWS folder.

Open a DOS-window (sometimes called a "Command Prompt") at this time.
Rather than changing to the folder containing eicar.com as the instructions suggest below, you could simply enter the full path-name to the file as part of the Debug load command.

For example: C:\WINDOWS>debug c:\temp\eicar.com

Once you've got the DOS prompt at the folder where you saved eicar.com, load the program into DEBUG by entering: debug eicar.com
(See green text in the pic below.) The only thing you'll see is a little dash [-] on the next line. This is the "command prompt" for DEBUG. Enter the letter d or D (case doesn't matter in DEBUG) and you should see a display similar to the one below. For each d command you enter, only 128 bytes are displayed at a time. But our program is just 68 bytes long, so you can ignore all the rest (under the yellow lines). Each line contains 16 bytes of code or data. [ All numbers displayed in DEBUG are hexadecimal. ( For a detailed study, see: What Is 'Hexadecimal'?) ]

The color in these pics is false; used for emphasis (Green = Commands you enter.
Text or lines in Blue, Yellow, or Violet are notes; NOT part of the original output ).

The two numbers separated by a colon (:) at the beginning of each line tell you where the first byte of that line is located in your computer's memory. The first number is called the Segment and the second is the Offset. [ For a detailed study see: Removing the Mystery from the SEGMENT:OFFSET Addressing scheme.]
In the pic above, we see that EICAR.COM was placed into memory beginning at a segment :offset location of 1795:0100. It's highly unlikely that your computer will load the program into the same segment of memory (1795), but the offset (0100) will be the same. DEBUG always loads .COM files so the first byte of the program has an offset of 0100 hex. [ The first 256 bytes (00h to FFh) of the segment contain information that DOS uses to run the program (that section is called the PSP - Program Segment Prefix.) ]

For comparison, here's what eicar.com looks like in the free Hex editor called Frhed:

(Here's a review of Frhed and its download link.)

This program is comprised of 20 individual steps:

(Program Instruction Step 1):
Now enter the letter r or R and you should see a display of your CPU's 16-bit registers similar to the pic below. The numbers at the beginning of the last line are always the segment :offset location of the x86 machine instruction which is ready for execution. As we step through this program, the offset will always equal the value in the IP register ( Instruction Pointer). For all true .COM files (size must be less than 64kb), the CX register will always contain the length of the program unless the code changes it. Here CX = 44 hex = 68 decimal bytes.

The Register Command (and Instruction Step 1).

Following the segment:offset (1795:0100) pair in the last line is the hex number 58 — this is the first byte of the program's code. It is then decoded as the assembly language instruction " POP AX " which means to take the last two bytes of the Stack (stored at offset FFFE and FFFF ) and move them into the AX register. [ My experience has taught me that DOS always 'zeroes-out' the last two bytes of a segment used by .COM programs ( the SP always being set to FFFE ), so executing POP AX should still leave us with zero in the AX register. The Stack Pointer will, of course, be changed to 0000 in the process. Under normal circumstances, however, I would never consider this to be an example of good programming practice and would recommend using an XOR AX,AX instruction to zero-out the AX register. ] (Instruction Step 2):
Enter a 't' (for Trace) at the DEBUG prompt to carry out the POP instruction. This will also display any register changes and decode the next instruction ( at

IP = 101). It's a logical operation called XOR (Exclusive-OR). Since AX is zero, this operation is equivalent to moving 214F into AX. [ Note that word-sized numerical values are stored in memory with the 'low byte' first and the 'high byte' last; 4F 21 in the instruction code is actually the word '214F'. ]
(Instruction Step 3):
Enter another 't' at this time and watch as AX changes to 214F and the next assembly instruction becomes: 50      PUSH   AX (with IP = 104). Before someone out there gets trigger-happy with the 't' key trying to find out what happens next, I'd better warn you that the final two instructions ( both of them are interrupts ) must be executed using the 'p' ( Proceed ) command !
Since there are no calls to a subroutine or loops within eicar.com itself, the p command could have been used for each step above. And it's the only execution command we'll use to finish this study. Executing this instruction (enter 'p' this time), places 214F onto 'the Stack' changing the SP register back to FFFE as seen above. Entering the Dump command with the offset fff0 confirms that the word 214F has been placed onto the Stack ( only one line of bytes instead of eight is shown this time because memory Dumps do not continue past the end of a segment).
(Instruction Steps 4 through 6):
As can be seen above, the next instruction ( IP = 105 ) is a logical AND of the value in the AX register (214F) and 4140 with the contents of AX being replaced by the result ( 0140 ); see below. The result is placed onto the Stack by a PUSH instruction ( use the command, 'd fff0' again to see this) and then into the BX register (with a POP BX at IP = 109) as follows:

[ Note that a PUSH instruction sends a copy of the data to the Stack leaving the value in the original location intact, whereas a POP instruction essentially removes data from the Stack. ] (Instruction Step 7): At IP = 10A, there's an XOR operation that involves only the low byte (AL) of the AX register. Remember that an Exclusive-OR means that the OR-ing of two bits can only be true (a one bit) if both bits are different. Thus, 40 hex (0100 0000) XOR-ed with 5C hex (0101 1100) results in: 1C (0001 1100) which replaces the 40 in the AL register. (Instruction Steps 8 through 11):
Carry out a few more 'p' commands ( beginning with the PUSH AX instruction at IP = 10C ) until AX contains 097B and the IP points to 112.

  AX=011C  BX=0140  CX=0044  DX=0000  SP=FFFC
  DS=1795  ES=1795  SS=1795  CS=1795  IP=010D
  1795:010D 5A            POP     DX

  AX=011C  BX=0140  CX=0044  DX=011C  SP=FFFE
  DS=1795  ES=1795  SS=1795  CS=1795  IP=010E
  1795:010E 58            POP     AX
                                               |   2    1    4    F
                                               | 0010 0001 0100 1111  XOR
  AX=214F  BX=0140  CX=0044  DX=011C  SP=0000  | 0010 1000 0011 0100 (2834)
  DS=1795  ES=1795  SS=1795  CS=1795  IP=010F  | -------------------   =
  1795:010F 353428        XOR     AX,2834      | 0000 1001 0111 1011
                                               |   0    9    7    B
[ The table to the right of the XOR instruction above gives the equivalents of 214F and 2834 in Binary providing a bit-level graphic display of this logical function. ]

(Instruction Steps 12 through 14):
Have you guessed what the number in the BX register (0140) refers to yet?
Hint: It's a location in memory near the end of our program; and we're running out of code! As we continue stepping through the code (see below), keep in mind how numerical WORD-sized values are stored in memory ( low-byte, high-byte). Just before and after you execute the instruction at IP = 114, enter the Dump command 'd 140 143' to see how this Subtract instruction changes the bytes in memory near the end of our program:
Now you know that a program can be written to change its own code while it runs (this happens quite often for 32-bit Windows programs at the time they are loaded into memory). In this case, eicar.com created a value that couldn't exist in the original code ( the byte CD ) enabling it to execute a critical DOS function (CD 21) near the end of its program (we'll discuss that function below).

(Instruction Steps 15 and 16):
The next two steps increase the value in the BX register in preparation for making a change at offset 0142:
 -r   <-- To see the registers again...
 AX=097B  BX=0140  CX=0044  DX=011C  SP=0000  BP=0000  SI=097B  DI=0000
 DS=1795  ES=1795  SS=1795  CS=1795  IP=0116   NV UP EI PL NZ AC PO NC
 1795:0116 43            INC     BX     [Step 15]
 -p

 AX=097B  BX=0141  CX=0044  DX=011C  SP=0000  BP=0000  SI=097B  DI=0000
 DS=1795  ES=1795  SS=1795  CS=1795  IP=0117   NV UP EI PL NZ NA PE NC
 1795:0117 43            INC     BX     [Step 16]
 -p
(Instruction Steps 17 and 18):
Step 17 is very similar to that of Step 14. As above, we'll be checking the contents of the location in the BX register both before and after executing the instruction at IP = 118. But this time we'll use the Dump command 'd 140 l4' (that's the letter 'el' and a 4 at the end of the command which means the range will be a 'length' of 4 bytes).
Normally this command, JGE - Jump if Greater than or Equal (to zero), would never be used in this situation! It's a conditional jump which means a condition should exist when the jump would not be made. But we always want to jump over the DATA section (011Ch to 013Fh) of this program:
-d 11c 13f
:0110                                      45 49 43 41               EICA
:0120  52 2D 53 54 41 4E 44 41-52 44 2D 41 4E 54 49 56   R-STANDARD-ANTIV
:0130  49 52 55 53 2D 54 45 53-54 2D 46 49 4C 45 21 24   IRUS-TEST-FILE!$
So why did the programmer use JGE 0140 (7D 24) instead of an un-conditional jump instruction? Simply because a short JMP instruction here would begin with the byte EB (decimal=235) which is again beyond the upper limit set for the program's characters. Since there are no conditions which keep execution from making this jump, JGE is an acceptable substitution here.

(Instruction Step 19):
This step contains one of the most important DOS Interrupts in existence: INT 21 (or CD 21). By 1992, there were at least 108 (00h - 6Ch) different functions being used under this interrupt and many of these functions have a number of sub-functions too! Just as most Windows programs call on code from within the Windows Operating System (API functions) rather than duplicating huge amounts of similar instructions inside of each program, DOS programs often use code from the DOS kernel (COMMAND.COM) or even the computer's BIOS. The function number for an INT 21 is placed in the AH register prior to execution. In this case, EICAR will execute Function 09h, the "Display String" function. The location of the string in memory is specified by the DS:DX registers (note the 011C in DX below) and a $-sign (24h) must be placed at the end of the string to indicate where it terminates. The string is simply displayed as one continuous line of characters without any new lines being possible!
(Instruction Step 20):
The program finally ends with INT 20h which was used by the original MS-DOS Version 1. For a very long time now, the recommended way of terminating DOS programs has been to use Function 4Ch of INT 21, but the programmer(s) of EICAR.com chose INT 20 to keep its size at a minimum rather than going through all the trouble of getting a 4C into the AH register and producing yet another CD byte! (Or, perhaps it was actually to maintain compatibility with old DOS versions.)

A Summary of the Program's Operation
as an Assembly Code Listing
(All digits are in Hexadecimal.)

 xxxx:0100 58            POP     AX
 xxxx:0101 354F21        XOR     AX,214F
 xxxx:0104 50            PUSH    AX
 xxxx:0105 254041        AND     AX,4140
 xxxx:0108 50            PUSH    AX
 xxxx:0109 5B            POP     BX       ;--> Places 0140 in BX

 xxxx:010A 345C          XOR     AL,5C
 xxxx:010C 50            PUSH    AX
 xxxx:010D 5A            POP     DX       ;--> Places 011C in DX

 xxxx:010E 58            POP     AX
 xxxx:010F 353428        XOR     AX,2834
 xxxx:0112 50            PUSH    AX
 xxxx:0113 5E            POP     SI
 xxxx:0114 2937          SUB     [BX],SI  ;--> changes bytes at 140-141

 xxxx:0116 43            INC     BX
 xxxx:0117 43            INC     BX
 xxxx:0118 2937          SUB     [BX],SI  ;--> changes bytes at 142-143

 xxxx:011A 7D24          JGE     0140     ;--> Jumps over data string to
                                             ; the last two instructions

 xxxx:011C  45 49 43 41 52 2D 53 54 41  EICAR-STA
 xxxx:0125  4E 44 41 52 44 2D 41 4E 54  NDARD-ANT        DATA  STRING
 xxxx:012E  49 56 49 52 55 53 2D 54 45  IVIRUS-TE     which is displayed
 xxxx:0137  53 54 2D 46 49 4C 45 21 24  ST-FILE!$       by the program.

 xxxx:0140 CD21          INT     21       ;--> DOS Function 09h:
                                             ; Displays the text.
 xxxx:0142 CD20          INT     20       ;--> Program Termination funct.

Last Update: 22 FEB 2006.


Inroduction

table ascii

Document d'origine ... href="http://table-ascii.com/

ASCII : ( American Standard Code for Information Interchange ( C0 Controls and Basic Latin, US-ASCII, ANSI (American National Standards Institute) X3.4:1986 ) ). ASCII definition & TABLE : Norme d'encodage informatique des caractères alphanumériques de l'alphabet latin. La norme ASCII (on prononce phonétiquement "aski") établit une correspondance entre une représentation binaire des caractères de l'alphabet latin et les symboles, les signes, qui constituent cet alphabet. Par exemple, le caractère "a" est associé à "01100001" et "A" à "01000001".

La norme ASCII permet ainsi à toutes sortes de machines de stocker, analyser et communiquer de l'information textuelle. En particulier, la quasi totalité des ordinateurs personnels et des stations de travail utilisent l'encodage ASCII.

Le codage ASCII est souvent complété par des correspondances supplémentaires afin de permettre l'encodage informatique d'autres caractères, comme les caractères accentués par exemple. Cette norme s'appelle ISO-8859 et se décline par exemple en ISO-8859-1 lorsqu'elle étend l'ASCII avec les caractères accentués d'Europe occidentale.

Il existe d'autres normes que l'ASCII, comme l'Unicode par exemple, qui présentent l'avantage de proposer une version unifiée des différents encodages de caractères complétant l'ASCII mais aussi de permettre l'encodage de caractères autres que ceux de l'alphabet latin. Le codage UTF8 de l'Unicode est une extension d'ASCII utilisant le 8e bit. (Source Dicodunet.com).

Transmissions en mode ASCII / Binaire :

Il existe deux modes de transmission des fichiers Informatiques : le mode ASCII et le mode Binaire. Un mauvais choix dans le mode de transmission peut rendre un fichier inexploitable.

En mode ASCII, le logiciel de transmission adressera le code ASCII de chaque caractère. Ce mode est particulièrement destiné à la transmission des fichiers dits "texte" (HTML, sources, scripts).

En mode Binaire, le logiciel de transmission enverra les bits par paquets. Ce mode convient aux fichiers, comme les exécutables, les images, les sons, etc...

Le choix du mode ASCII / binaire est souvent laissé à l'appréciation du logiciel de transmission qui déterminera automatiquement le mode approprié en fonction de l'extension ou du contenu du fichier à transmettre.

Certaines transmissions sont effectuées en mode hexadécimal. Ce mode de transmission permet de transmettre des fichiers binaires en mode ASCII, c'est à dire en n'utilisant que les 128 premiers caractères de la Table ASCII .

Autres ressources et représentations de la table ascii (anglais)

ISO 646
ASCII - ISO 8859-1 avec table des entités HTML 3.0 - Quelques bonnes ressources
ASCII Character Set Revisé, ANSI X3.110-1983
ASCII Character Set, ANSI X3.4-1968
ASCII Table des symboles ASCII - Avec codes HTML
Decimal ASCII pour HTML
EBCDIC Character Set - Une autre norme (désuète ?)
BAUDOT - Encore une autre norme ...
BAUDOT En savoir plus sur BAUDOT
Brief History of Character Codes - Une vraie bible !
Braille Chart - La table des codes pour personne mal-voyantes.

Développeurs, Webmasters, Créateurs !
Protégez gratuitement vos sites, codes sources, scripts,...
contre la copie illicite !

Dépôt légal durant 25 ans auprès d'un Officier Ministériel.
Protection intellectuelle internationale, à vie + 70 ans.

CopyrightFrance.com